Sistema de detección, explicación y
visualización de comunidades

System for community detection, explanation and visualization

Trabajo de fin de grado del Grado en Ingeniería Informática
Facultad de Informática

Autores
Pablo Daurell Marina

Alberto García Doménech

Directores
Belén Díaz Agudo

Jose Luis Jorro Aragoneses

Curso 2021–2022



Sistema de detección, explicación y
visualización de comunidades

System for community detection, explanation and visualization

Memoria que se presenta para el Trabajo de Fin de Grado

Pablo Daurell Marina y Alberto García Doménech

Dirigido por Belén Díaz Agudo1 y Jose Luis Jorro Aragoneses1

1Departamento de Ingeniería del Software e Inteligencia Artificial

Facultad de Informática
Universidad Complutense de Madrid

Madrid, 2022





Resumen

En las últimas décadas, los museos han comenzado varios procesos para involucrar más a
sus visitantes en sus exposiciones, interesándose más en sus opiniones e intereses y tenién-
dolas en cuenta para fomentar las visitas. A partir de esta recopilación de información de
los visitantes, se pueden establecer grupos de individuos que comparten intereses, a raíz
de los cuáles se puede extraer información relevante sobre el conjunto de visitantes.
En este proyecto se desarrollará una arquitectura software que, aplicando distintos mé-
todos, permitirá encontrar comunidades implícitas en los datos de visitantes de museos y
aportará una visualización y explicación de las características de cada una de ellas para
facilitar su interpretación.

Palabras clave
Clustering, comunidades, visualización, explicación, museos, similitud, grafo

ii



Abstract

In recent decades, museums have started several processes to involve their visitors in their
exhibitions, taking into account their interests and opinions in order to encourage visits.
From this collection of visitor information, it is possible to establish groups of individuals
who share the same interests, from which relevant information about the visitor pool can
be extracted.
In this project there will be a development of a software arquitecture that, by applying
different methods, will find implicit communities among the museum visitors data and
will provide a visualization and explanation of the features of each one of them to easily
interpret them.

Key words
Clustering, communities, visualization, explanation, museum, similarity, graph

iii



Sobre TEFLONX

Teflon X(cc0 1.0(documentación) MIT(código))es una plantilla de LATEX
creada por David Pacios Izquierdo con fecha de Enero de 2018. Con atri-
buciones de uso CC0.
Esta plantilla fue desarrollada para facilitar la creación de documentación profesional pa-
ra Trabajos de Fin de Grado, Trabajos de Fin de Máster o Doctorados. La versión usada
es la X
V:X Overleaf V2 with XeLaTeX, margin 1in, bib

Contacto
Autor: David Pacios Izquiero
Correo: dpacios@ucm.es

ASCII: ascii@ucm.es

Despacho 110 - Facultad de Informática

iv

dpacios@ucm.es
ascii@ucm.es


Índice general

Página

1. Introducción 1
1.1. Motivación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2. Objetivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

1.2.1. Plan de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3. Estructura de la memoria . . . . . . . . . . . . . . . . . . . . . . . . . . 4

2. Estado del arte 6
2.1. Medidas de similitud . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.2. Técnicas de Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.2.1. Algoritmos de partición . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.2. Algoritmos jerárquicos . . . . . . . . . . . . . . . . . . . . . . . . 11
2.2.3. Algoritmos basados en la densidad . . . . . . . . . . . . . . . . . 13

2.3. Visualización de grafos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3.1. Herramientas de visualización de grafos . . . . . . . . . . . . . . . 14
2.3.2. Algoritmos de distribución de grafos . . . . . . . . . . . . . . . . 17

2.4. Resumen del capítulo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

3. Desarrollo de la arquitectura 20
3.1. Caso de uso: Museo del Prado . . . . . . . . . . . . . . . . . . . . . . . . 20

3.1.1. Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3.2. Modelado de comunidades . . . . . . . . . . . . . . . . . . . . . . . . . . 23

3.2.1. Similitud entre usuarios . . . . . . . . . . . . . . . . . . . . . . . 24
3.2.2. Similitud entre obras . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.3. Clustering . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3.4. Explicación y visualización . . . . . . . . . . . . . . . . . . . . . . . . . . 30

3.4.1. Explicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.4.2. Visualización . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

4. Descripción funcional de la arquitectura 34
4.1. Interfaz de usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
4.2. Generación de matrices de similitud . . . . . . . . . . . . . . . . . . . . . 35

4.2.1. Interfaz gráfica para calcular las similitudes . . . . . . . . . . . . 37
4.3. Formación de los clusters . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

v



UCM

4.3.1. Interfaz gráfica para generar los clusters . . . . . . . . . . . . . . 39
4.4. Generación de las explicaciones . . . . . . . . . . . . . . . . . . . . . . . 39

4.4.1. Interfaz gráfica para generar las explicaciones . . . . . . . . . . . 40
4.5. Generación de la visualización . . . . . . . . . . . . . . . . . . . . . . . . 42

4.5.1. Interfaz gráfica para la visualización de las comunidades . . . . . 43

5. Conclusiones y trabajo futuro 45
5.1. Conclusiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
5.2. Trabajo futuro . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6. Trabajo Individual 47
6.1. Alberto García . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
6.2. Pablo Daurell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

7. Introduction 51
7.1. Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
7.2. Objectives . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

7.2.1. Work plan . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
7.3. Document structure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

8. Conclusions and future work 55
8.1. Conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
8.2. Future work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

vi



Índice de figuras

2.1. Comparación entre la distancia Manhattan y la distancia Euclidiana. Ima-
gen sacada de referencia [19] . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.2. Convergencia de K-means a lo largo de 7 iteraciones. Imagen sacada de
referencia. [4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

2.3. Ejecución de un algoritmo kmedoids. Imagen sacada de referencia [3] . . 11
2.4. División jerárquica utilizando un algoritmo aglomerativo y uno divisivo.

Imagen sacada de referencia [11] . . . . . . . . . . . . . . . . . . . . . . . 12
2.5. Clusters con diferentes formas. Imagen sacada de referencia. [26] . . . . . 13
2.6. Interfaz gráfica de Gephi . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.7. Ejemplo de grafo construido y visualizado usando NetworkX . . . . . . . 16
2.8. Ejemplo de visualización de un grafo con PyVis . . . . . . . . . . . . . . 16
2.9. Ejemplo de aplicar Fruchterman-Reingold a un grafo . . . . . . . . . . . 17
2.10. Ejemplo de aplicar ForceAtlas2 a un grafo . . . . . . . . . . . . . . . . . 18

3.1. Estructura básica del flujo de trabajo de la arquitectura a desarrollar . . 20
3.2. Ejemplo de la estructura básica de los datos aplicada al caso de los usuarios

del Museo del Prado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
3.3. Ejemplo de la estructura básica de los datos aplicada al caso de las obras

del Museo del Prado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.4. Cálculo de la similitud entre usuarios mediante la similitud de sus atributos 24
3.5. Formato en el que se representan los gustos de los usuarios sobre las obras 26
3.6. Espacios de colores RGB y HSV [29] . . . . . . . . . . . . . . . . . . . . 27
3.7. Función de distancia entre dos colores en formato HSV [6] . . . . . . . . 28
3.8. Cálculo de la similitud entre obras mediante la similitud de sus atributos 28
3.9. Representación visual de centroide y medoide. (Imagen sacada de referencia

[7]) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.10. Variación del índice Davies Bouldin al aumentar la cantidad de clusters . 29
3.11. Ejemplo básico de la creación de un individuo explicador a partir de una

comunidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.12. Comunidad creada teniendo en cuenta solo la edad de los usuarios (visua-

lización creada con Gephi) . . . . . . . . . . . . . . . . . . . . . . . . . . 32

4.1. Diagrama con la interconexión entre las distintas clases que implementan
el flujo de trabajo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34

vii



UCM

4.2. 5 obras del Museo del Prado . . . . . . . . . . . . . . . . . . . . . . . . . 36
4.3. Matriz de similitud entre 5 obras del Museo del Prado . . . . . . . . . . . 36
4.4. Selección de los datos a través de la interfaz . . . . . . . . . . . . . . . . 37
4.5. Selección de los atributos a utilizar, las funciones de similitud y los pesos,

para las obras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
4.6. Selección de matriz de similitud de las obras . . . . . . . . . . . . . . . . 37
4.7. Selección de los atributos a utilizar, las funciones de similitud y los pesos,

para los usuarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
4.8. Selección de matriz de similitud de las obras . . . . . . . . . . . . . . . . 38
4.9. Selección de los algoritmos de clustering . . . . . . . . . . . . . . . . . . 39
4.10. Fichero JSON de ejemplo con los datos extraídos de una comunidad . . . 40
4.11. Selección de los atributos a usar en la explicación . . . . . . . . . . . . . 40
4.12. Explicación de uno de los clusters resultantes . . . . . . . . . . . . . . . . 41
4.13. Explicación con las graficas de distribucción de los distintos valores de un

atributo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
4.14. Botón para generar la visualización . . . . . . . . . . . . . . . . . . . . . 43
4.15. Visualización de varias comunidades obtenidas . . . . . . . . . . . . . . . 43
4.16. Visualización de la información de un nodo del grafo . . . . . . . . . . . 44

viii



Capítulo 1

Introducción

Para comenzar a hablar más en detalle de este proyecto, en este primer capítulo se va a
introducir el tema principal del mismo, cuáles son las motivaciones para llevarlo a cabo
y que objetivos y tareas se han de desarrollar para conseguir todo lo propuesto.

Todo el código desarrollado durante el proyecto se encuentra en el siguiente repositorio
de github: https://github.com/AlbertoGarciaDomenech/Comunidades-en-museos

1.1. Motivación

Los museos son una parte fundamental a la hora de promover el patrimonio cultural entre
la población. Sin embargo, a lo largo de las últimas décadas, el número de personas que
visitan museos se ha visto reducido. Para contrarrestar esto, los museos y otras institu-
ciones culturales han tomado varias medidas para fomentar las visitas a museos entre
la población. Una de estas medidas es hacer al público más participe de las distintas
actividades y exposiciones que ofrecen [28] y que estas no se construyan solo a partir de
las decisiones del propio museo, si no también escuchando las voces de sus visitantes. El
proyecto SPICE [2], es un proyecto que se encarga de explorar esta idea a través de la
agrupación de los visitantes en comunidades a partir de las cuales poder realizar recomen-
daciones de nuevos contenidos y ayudar a los visitantes a construir una representación
de si mismos y comprender mejor sus gustos e intereses. Pero, ¿a qué nos referimos con
agrupar a los visitantes en comunidades?.

Una comunidad es un conjunto de personas que tienen características, opiniones, valores
u objetivos comunes o desempeñan un rol común dentro de una sociedad. Dentro de un
conjunto de personas, se pueden encontrar multitud de características comunes entre ellas,
a raíz delas cuales pueden establecerse relaciones entre las personas para formar comu-
nidades de individuos similares entre sí. Detectar estas comunidades ayuda a estructurar
los datos de un conjunto de individuos desde un enfoque de más alto nivel, simplifi-
cando el entendimiento de las relaciones entre individuos y facilitando la extracción de

1

https://github.com/AlbertoGarciaDomenech/Comunidades-en-museos


UCM

conocimiento sobre los datos (en este caso, sobre el conjunto de personas) [25].

El proceso para modelar estas comunidades puede realizarse teniendo en cuenta multitud
de factores y puede ser relativamente sencillo si solo se tienen en cuenta un conjunto
reducido de estos, sin embargo, a medida que se incrementa el número de características
a tener en cuenta el trabajo se complica, pero a su vez, las relaciones entre individuos
son más complejas y las comunidades obtenidas pueden aportar información más intere-
sante.

Para detectar comunidades dentro de un conjunto de datos existen distintos métodos,
capaces de tener en cuenta un gran número de características de distintos individuos y
encontrar relaciones implícitas entre ellas a través de las cuales poder establecer una serie
grupos de individuos. No obstante, estos métodos funcionan de una manera opaca para el
usuario, aportando como resultado de su ejecución una manera de agrupar los datos pero
sin explicar que características se han tenido en cuenta para formar cada grupo.

Teniendo en cuenta todo esto y a partir de las ideas establecidas en el proyecto SPICE
[2], en este proyecto se diseñará e implementará una arquitectura software que permitirá
utilizar métodos de detección de comunidades para agrupar a los visitantes de un museo
y además tratará de solventar la falta de transparencia de estos métodos a través de
técnicas para interpretar sus resultados y generar explicaciones y visualizaciones de estos,
que sean fácilmente interpretables por cualquier persona ajena al funcionamiento interno
de los métodos de detección de comunidades.

1.2. Objetivos

El objetivo principal es desarrollar una arquitectura reutilizable para analizar el compor-
tamiento de los visitantes de un museo. Para ello, esta arquitectura debe ser capaz de:
permitir cargar unos datos con características de los visitantes del museo, de las obras
expuestas en este y las emociones de los visitantes respecto a las obras; agrupar en comu-
nidades a los visitantes con características similares, pudiendo utilizar distintos métodos
para obtener esas similitudes y, finalmente, ofrecer herramientas para explicar y visualizar
las comunidades obtenidas, facilitando la interpretación de estas.

Para completar este objetivo, durante el desarrollo hemos definido los siguientes objetivos
específicos:

Objetivo 1: Definir varios métodos para calcular la similitud entre dos obras, para
después tenerlo en cuenta a la hora de calcular la similitud de los visitantes en base
a sus preferencias y más adelante poder detectar comunidades de visitantes con
preferencias similares.

Objetivo 2: Establecer una manera de calcular cómo de similares son dos indi-
viduos en base a sus características demográficas y a los gustos que estos tienen
sobre distintas obras, para poder aplicar métodos de clustering basados en estas

2



UCM

similitudes que agrupen a los individuos en distintas comunidades.

Objetivo 3: A partir de cada comunidad calculada, generar una explicación que
caracterice a los individuos que la forman en base a sus atributos en común y ayude
a comprender cuál es la lógica detrás de su formación. Además, explorar distintas
formas de poder representar las comunidades de una manera visual.

Objetivo 4: Crear una interfaz que ayude los usuarios finales a utilizar las fun-
cionalidades de la arquitectura implementada, permitiéndoles ver y comprender los
resultados obtenidos en los objetivos específicos anteriores. Esta interfaz permiti-
rá que, partiendo de unos datos iniciales, se realice el calculo de similitudes, la
agrupación en comunidades y la generación de explicaciones y visualizaciones, dan-
do la posibilidad de modificar los parámetros de cada fase para generar distintos
resultados.

Para desarrollar una arquitectura que cumpla estos objetivos enfocaremos el desarro-
llo teniendo en cuenta tres tipos de posibles usuarios finales. Por un lado, un “usuario
diseñador”, que entienda de clustering y medidas de similitud y comprenda como está
implementada la lógica del proyecto, pudiendo implementar nuevas medidas de similitud
y trabajar directamente con el código. Por otro lado, un “responsable del museo”, que
puede no tener conocimientos informáticos pero puede ver e interpretar las comunidades
de visitantes, además puede aportar conocimiento experto sobre qué características de
los visitantes pueden ser más interesantes a tener en cuenta a la hora de agruparlos. Por
último, un “usuario visitante” cuya información se haya utilizado para generar las comu-
nidades y pueda ver a qué comunidad se le ha asignado y cuáles son los gustos de los
otros visitantes pertenecientes a su misma comunidad.

1.2.1. Plan de trabajo

A partir de los objetivos definidos, podemos especificar una división en tareas para una
mayor organización a la hora de desarrollar el proyecto.

Objetivo 1:

• Tarea 1.1: Investigar y aprender sobre el funcionamiento de las medidas de
similitud.

• Tarea 1.2: Estudiar y comprender el dominio de los datos, concretamente de
las obras.

• Tarea 1.3: Definir medidas de similitud específicas para las obras.
• Tarea 1.4: Revisar y comprobar el funcionamiento de las medidas definidas.
• Tarea 1.5: Implementar todo el código resultante en una clase propia.

Objetivo 2:

• Tarea 2.1: Estudiar y comprender el dominio de los datos, concretamente de
los visitantes.

3



UCM

• Tarea 2.2: Definir una medida de similitud global entre usuarios.
• Tarea 2.3: Definir medidas de similitud específicas para los atributos de los

usuarios.
• Tarea 2.4: Revisar y comprobar el funcionamiento de las medidas definidas.
• Tarea 2.5: Investigar y aprender sobre los métodos de clustering existentes.
• Tarea 2.6: Probar diferentes métodos de clustering.
• Tarea 2.7: Elegir y aplicar métodos de clustering sobre los datos.
• Tarea 2.8: Implementar todo el código resultante en una clase propia.

Objetivo 3:

• Tarea 3.1: Estudiar los resultados obtenidos al aplicar los métodos de cluste-
ring.

• Tarea 3.2: Extraer la información común de las diferentes comunidades obte-
nidas.

• Tarea 3.3: Explorar maneras de mostrar e interpretar la información.
• Tarea 3.4: Estudiar y aprender sobre diferentes herramientas y métodos de

visualización de grafos.
• Tarea 3.5: Generar un grafo con la información y visualizarlo.
• Tarea 3.6: Implementar todo el código resultante en una clase propia.

Objetivo 4:

• Tarea 4.1: Elegir una manera de implementar una interfaz gráfica usando
Python.

• Tarea 4.2: Crear una interfaz que permita introducir datos y conecte todo el
código generado en los anteriores objetivos para conseguir un flujo de trabajo
completo.

1.3. Estructura de la memoria

Este documento está dividido en ocho capítulos. En el primero de ellos se introduce
la temática del trabajo, los problemas que van a tratarse, qué objetivos se pretenden
conseguir y de qué manera.

En el segundo capítulo se habla sobre distintos métodos para realizar tareas de detección
de comunidades y distintas herramientas para llevar a cabo tareas de visualización, que
pueden ser de utilidad para el desarrollo del proyecto.

El tercer capítulo trata el proceso seguido para realizar cada uno de los objetivos pro-
puestos, las distintas decisiones tomadas y las técnicas y herramientas utilizadas.

En el cuarto capítulo se desarrolla más en detalle cómo se han implementado las deci-
siones tomadas en el capítulo anterior, se explica el funcionamiento básico de la interfaz
desarrollada y se muestran algunos resultados producidos por la arquitectura desarrolla-
da.

4



UCM

En el quinto capítulo se da un cierre al desarrollo del proyecto sacando conclusiones de
todo el proceso y sus resultados y estableciendo cómo podría continuarse este trabajo en
un futuro.

El sexto capítulo está dedicado a mostrar las contribuciones y el trabajo individual de
ambos autores del proyecto.

Por último, los capítulos siete y ocho son una traducción al inglés de los capítulos uno y
seis respectivamente, con el fin de cumplir la normativa estipulada que pide la traducción
de la introducción y las conclusiones.

5



Capítulo 2

Estado del arte

En este capítulo se describe del estado del arte en los algoritmos de detección de comu-
nidades y los métodos de visualización de estas, incluyendo los principales métodos de
clustering, las medidas de similitud más utilizadas para estos algoritmos y los métodos y
herramientas más utilizadas para visualizar comunidades de datos.

2.1. Medidas de similitud

El concepto de similitud es una de las bases fundamentales a la hora de abordar la división
en comunidades, ya que permite identificar a los objetos que sean parecidos, juntarlos y
separarlos de aquellos que no lo son. Por otra parte, el concepto de distancia (cómo de
separados están dos objetos entre sí) es igual de importante y como podemos ver mide lo
contrario que la similitud, por ello la relación entre ellos está definida como [11]:

similitud(i, j) = 1− distancia(i, j) (2.1)

Por lo que la distancia entre dos puntos será:

distancia(i, j) = 1− similitud(i, j) (2.2)

Para calcular la similitud entre dos objetos hay que calcular primero la similitud entre sus
atributos ya que de estos dependerá la similitud final. Dependiendo del tipo de atributo
(binario, numérico, nominal, etc.) que sea podremos compararlos de una manera u otra.
Las funciones utilizadas para comparar dichos atributos se conocen como medidas de
similitud.
Existen infinidad de medidas de similitud y de distancia que abarcan desde una simple
igualdad a funciones matemáticas complejas, entre ellas las más populares son:

Distancia Euclidiana: es la función de distancia más utilizada para atributos
numéricos que estén en un espacio euclídeo, se define como:
dados dos puntos P y Q con coordenadas cartesianas (p1, p2, ..., pn) y (q1, q2, ..., qn)

dE(P,Q) =
√

(p1 − q1)2 + (p2 − q2)2 + ...+ (pn − qn)2 (2.3)

6



UCM

Distancia Manhattan: la distancia entre dos puntos, medida a lo largo de los
ejes con ángulos rectos. Llamada así por la referencia a medir distancias en ciudades
donde no se puede ir en diagonal porque hay edificios y hay que ir por calles paralelas
y perpendiculares entre sí. En un plano con P en (p1, p2, ..., pn) y Q en (q1, q2, ..., qn)

se calcula como:

dM(P,Q) = |(p1 − q1) + |(p2 − q2)|+...+ |(pn − qn)| (2.4)

Distancia Minkowski: la generalización de las distancias Manhattan y Euclidiana.
Se define como:

d(i, j) = h

√
|xi1xj1|h+|xi2xj2|h++ |xipxjp|h (2.5)

Siendo h un número real ≥ 1 donde, si es igual a 1 representa la distancia Manhattan
y si es igual a 2 la distancia Euclidiana. Podemos ver en la Figura 2.1 las diferencias
a la hora de calcular ambas.

Similitud de Jaccard: también conocida como índice o coeficiente de Jaccard, es
una medida de similitud que compara dos conjuntos, calculando la división de el
tamaño de la intersección de los dos grupos entre el tamaño de la unión.

Similitud del coseno: similitud entre dos vectores, utilizada normalmente para
calcular la similitud entre dos documentos, calcula el coseno del ángulo entre los
dos vectores y determina si están dirigidos hacia la misma dirección (se utiliza la
dirección para evitar que al comparar documentos de diferentes tamaños, los que
tengan más elementos tengan más cosas en común). Con dos vectores X formado
por (x1, x2, ...xn) y Y formado por (y1, y2, ..., yn) y dado ||X||=

√
x2
1 + x2

2 + ...+ x2
n

define como:
simC(X, Y ) =

xy

||x||||y||
(2.6)

Esta medida aunque muy útil para calcular la distancia entre dos vectores solo se
puede utilizar si se puede calcular la distancia Euclidiana de sus atributos.

7



UCM

Figura 2.1: Comparación entre la distancia Manhattan y la distancia Euclidiana. Imagen
sacada de referencia [19]

2.2. Técnicas de Clustering

El clustering se define como un método de división y agrupación de objetos de un conjunto
en subconjuntos de objetos buscando maximizar la similitud entre los miembros de un
subconjunto y minimizar la similitud con los miembros de los demás subconjuntos [21].
A estos subconjuntos se les denomina clusters. Es una técnica utilizada en tareas de
clasificación pero a diferencia otros métodos se trata de una técnica de aprendizaje no
supervisado ya que no cuenta con la información de la clase a la que pertenece cada
objeto realmente.

Las semejanzas y diferencias entre los objetos se calcularán en base a los atributos de
dichos objetos utilizando medidas de distancia o de similitud. A pesar de que las medidas
de similitud tienen un gran peso a la hora de dividir a los objetos, dependiendo de la
técnica de clustering seleccionada se podrán obtener distintos clusters aunque el conjunto
de datos y las medidas de similitud utilizadas sean las mismas.

Existe una gran variedad de algoritmos de clustering. Los algoritmos utilizados mayo-
ritariamente pueden dividirse en cuatro categorías: algoritmos de partición, algoritmos
basados en la densidad de los clusters, algoritmos jerárquicos y algoritmos basados en un
grid [11]. En esta memoria, nos centraremos en describir los tres primeros ya que son los
que hemos utilizado y estudiado en este proyecto.

8



UCM

2.2.1. Algoritmos de partición

Los algoritmos de partición son los algoritmos más populares y fundamentales de las
técnicas de clustering. Necesitan un valor k como parámetro que será el número de clusters
en los que se va a dividir el conjunto de datos. El algoritmo partirá los datos en k
subgrupos, que cumplirán dos restricciones [16]:

Cada subgrupo estará formado por al menos un objeto

Los grupos serán exclusivos: cada objeto deberá pertenecer a un único subgrupo

Gracias a estas restricciones deducimos que el número de particiones tiene que ser menor
o igual al número total de objetos (k ≤ n) y que la unión de todos los grupos será el
conjunto de datos original.

Aunque el algoritmo pueda partir los datos en k clusters, k no tiene porque ser un valor
que nos vaya a dar buenos resultados por lo que existen diferentes maneras de calcular
número de clusters óptimo, como el índice Davies-Bouldin [5]: valor que mide la calidad
de la partición de un conjunto de datos, calculado usando la distancia entre los centros
de cada cluster y la distancia promedia entre un individuo y el centro de su cluster
asignado.

Después de dividir los datos en k clusters, el algoritmo procederá a optimizar la disposición
de los objetos en los clusters a partir de una función de similitud, hasta lograr maximizar
la semejanza entre objetos del mismo cluster y minimizarla entre clusters diferentes.
Los algoritmos más utilizados de este tipo son el K-means [20], K-medoids y CLARA
(Clustering Large Aplications) aunque dado que el algoritmo CLARA es una extensión
del K-medoids para lidiar con datos de gran tamaño procederemos a explicar los dos
primeros:

K-means

El algoritmo k-means es el algoritmo de partición más popular. Este algoritmo determina
primero k puntos, generados aleatoriamente, que actuarán como el centro de los k clusters
(conocidos como centroides) y asignará a los objetos con mayor cercanía a estos centroi-
des a su cluster. Después calculará los nuevos centroides como la media de los objetos
del cluster y volverá a asignar a los objetos más cercanos. En la Figura 2.2 podemos ver
un ejemplo del funcionamiento del algoritmo a lo largo de siete iteraciones, donde separa
un conjunto de datos en tres comunidades (la k especificada). Esto seguirá hasta que
no haya variación en los objetos de los clusters o hasta que converja según un criterio
anteriormente especificado. Los centroides al calcularse con la media no tienen por qué
coincidir con un objeto real del conjunto de datos.
Un problema de este algoritmo es que es muy sensible a la aparición de datos con valores
atípicos, ya que como estos objetos están muy alejados del resto de los datos pueden llegar
a distorsionar la media por lo que el cluster quedaría definido de manera incorrecta pu-
diendo provocar la inclusión o eliminación de elementos que deberían pertenecerle.

9



UCM

Figura 2.2: Convergencia de K-means a lo largo de 7 iteraciones. Imagen sacada de
referencia. [4]

K-medoids

Es una técnica que funciona igual que el k-means salvo que está basado en medoides, es
decir, los objetos reales del dataset más cercanos a los centroides.

Originalmente se desarrolló el algoritmo PAM (Partition Around Medoids)[17] basado
en encontrar los k objetos representativos de un conjunto de datos y construir clusters
alrededor de ellos. Aunque es una técnica muy potente es muy ineficiente por lo que se
propusieron variaciones de este algoritmo para conjuntos muy grandes de datos como el
algoritmo CLARA [16] y otras modificaciones de k-medoids más parecidas al funciona-
miento de k-means para encontrar los medoides originales[22] donde se calcula una vez
la matriz de distancia de los objetos y se utiliza para iterativamente encontrar los nuevos
medoides.

En la Figura 2.3 se puede ver un ejemplo de la ejecución de k-medoids.

10



UCM

Figura 2.3: Ejecución de un algoritmo kmedoids. Imagen sacada de referencia [3]

2.2.2. Algoritmos jerárquicos

Los algoritmos de partición cumplen la función de dividir un conjunto de datos en sub-
conjuntos pero asumiendo que no existe ninguna relación de jerarquía entre los diferentes
datos. Aunque esto puede ser verdad en muchos casos, hay ocasiones donde existe una
jerarquía clara (por ejemplo alumnos y profesores que vayan a ver una exposición) o
queremos encontrar una jerarquía oculta entre nuestros datos.

Podemos dividir en tres los algoritmos jerárquicos [11] según las técnicas que aplican:
Deterministas, probabilistas y métodos Bayesianos. En el primer grupo se encuentran
aquellos que usan métodos algorítmicos y tratan a los datos de manera determinista
calculando los clusters utilizando la distancia entre objetos. En el segundo grupo tenemos
métodos que utilizan modelos probabilistas para dividir los clusters y calcular la calidad
de la división según una función de fitness. Por último, tenemos los métodos Bayesianos
que en vez de devolver una única división en clusters devuelven un grupo de estructuras
de clusters y sus probabilidades.

Los métodos más utilizados son los algorítmicos, que podemos dividir en dos algoritmos:
aglomerativos y divisivos (como podemos ver en la Figura 2.4). Esta división es en base
a la estrategia que sigamos para definir los cluster, si seguimos una estrategia bottom-up
(definir al principio los elementos y establecer una estructura más compleja a partir la
unión entre ellos) estaremos utilizando el algoritmo aglomerativo. Por otro lado, si siguié-
semos una estrategia top-down (establecer primero una estructura compleja sin entrar en
detalle específico y definir posteriormente a través de la división de la estructura los deta-
lles de los elementos) utilizaríamos el divisivo. Los algoritmos jerárquicos más utilizados

11



UCM

son los aglomerativos (entre ellos el algoritmo AGNES, AGglomerative NESting [16]) ya
que los divisivos tienen un gran coste computacional (como el algoritmo DIANA, DIvisive
ANAlysis [16]). La estructura que normalmente se utiliza para representar la jerarquía
de los clusters se conoce como dendrograma, una estructura en forma de árbol.

Figura 2.4: División jerárquica utilizando un algoritmo aglomerativo y uno divisivo. Ima-
gen sacada de referencia [11]

Aglomerativo

El algoritmo aglomerativo define un cluster por cada objeto del conjunto de datos y, des-
pués, procede a unir los clusters más cercanos para acabar creando uno solo. Este proceso
lo hace de manera iterativa hasta que se hayan satisfecho las condiciones necesarias para
terminar la ejecución del algoritmo.
Es importante calcular correctamente qué clusters se deberían unir ya que una vez unidos
no se pueden volver a dividir por lo que una unión incorrecta de clusters puede llevar a
una división y una jerarquía sin sentido. El cálculo de la cercanía de los cluster puede ser
de tres maneras:

Enlace único Calcula la distancia entre todos los puntos de un cluster a todos los puntos
de otro cluster y se queda con la mínima

distmin(Ci, Cj) = mı́n
p∈Ci,p′∈Cj

{|p− p′|} (2.7)

Establece un umbral máximo para la distancia mínima entre clusters y una vez se
supere el umbral en todos los clusters finaliza el algoritmo.

12



UCM

Enlace completo Calcula la distancia máxima entre todos los puntos de un cluster a
todos los puntos de otro cluster y se queda con la máxima

distmax(Ci, Cj) = máx
p∈Ci,p′∈Cj

{|p− p′|} (2.8)

Define un umbral máximo y finaliza el algoritmo cuando la distancia entre los
clusters más cercanos excede dicho umbral.

Media Dado que al calcular la distancia usando el enlace único o completo se tiende a
ser muy sensible a los valores atípicos o los que son simplemente ruido, al calcular
la media de las distancias podemos superar este problema.

distmedia(Ci, Cj) =

∑
p∈Ci,p′∈Cj

|p− p′|

ninj

(2.9)

2.2.3. Algoritmos basados en la densidad

Los algoritmos de partición y de jerarquía son los más utilizados pero están diseñados
para encontrar clusters con forma esférica, por lo que si queremos encontrar clusters
con una forma arbitraria no circular estos algoritmos fallarían al determinar los clusters
de manera incorrecta sobre todo en los bordes ya que la presencia de valores atípicos
contribuirían al ruido. Como podemos observar en la Figura 2.5 si usásemos este tipo de
algoritmos en los primeros datos podríamos reconocer los clusters adecuadamente pero
en el resto de datos estos algoritmos nos devolverían clusters incorrectos.
Por esta razón, se desarrollaron algoritmos basados en la densidad de regiones de datos
en el espacio con la finalidad de encontrar clusters no esféricos. El algoritmo más utilizado
de este tipo es el algoritmo DBSCAN (Density Based Spatial Clustering of Applications
with Noise) [8], basado en encontrar objetos que tienen un vecindario denso y conectar
esos objetos con los de su vecindario para formar las regiones densas.

Figura 2.5: Clusters con diferentes formas. Imagen sacada de referencia. [26]

DBSCAN

El algoritmo DBSCAN determina la densidad de un objeto como el número de objetos
que estén cerca de él. Para determinar si un objeto está cerca de otro se define un valor

13



UCM

ϵ >0 que actuará como el radio del objeto, esto define el ϵ-vecindario. Contaremos que
un objeto está dentro de ese vecindario si está a menor distancia que ϵ. La densidad de
un vecindario se calcula como el número de objetos en ese vecindario (gracias a que los
vecindarios tienen un tamaño fijo de radio ϵ). Un objeto será central si su ϵ-vecindario
tiene al menos MinPts (otro parámetro predeterminado como ϵ). DBSCAN después de
identificar los objetos centrales formará las regiones densas a través del concepto de
densidad-alcanzable directa y densidad-alcanzable: dados dos objetos q y p, q será direc-
tamente alcanzable desde p si está dentro del ϵ-vecindario de q y p es un objeto central.
En cambio q será alcanzable si existe una serie de objetos q1, ...qn dado q1 = q, qn = p y
se cumple que qi+1 es directamente alcanzable desde qi.
Para formar las regiones densas, DBSCAN conecta los objetos si existe un objeto entre
ellos que sea alcanzable para los dos. Finalmente un cluster basado en estas regiones se
define como un subconjunto tal que todos los objetos en ese conjunto estén conectados y
no exista ningún objeto fuera de ese conjunto que esté conectado con un objeto pertene-
ciente a él.

2.3. Visualización de grafos

Una parte fundamental de este proyecto es la visualización de las comunidades obtenidas
al aplicar los algoritmos de clustering. Los datos usados para generar las comunidades
se relacionan entre sí formando una estructura de red que puede representarse de ma-
nera visual usando grafos, donde los datos son nodos y se conectan ente sí mediante
aristas.

2.3.1. Herramientas de visualización de grafos

Existen multitud de herramientas para trabajar con grafos, muchas de ellas ofrecen una
gran variedad de opciones para trabajar con ellos pero siempre se centran principalmente
en su visualización. En esta sección hablaremos de algunas de estas herramientas que
pueden ser de utilidad para realizar los objetivos de este proyecto.

Gephi

Una de estas herramientas, y probablemente la más utilizada y con mayor cantidad de
opciones es Gephi, un programa de código abierto que permite visualizar redes en tiempo
real, permitiendo modificar distinos parámetros para generar distintas formas de visuali-
zación. También permite ver en en detalle las características de los nodos y las aristas de
la red e incluso aplicar ciertos cálculos sobre ella para obtener distintas medidas. [1]
En nuestro caso, nos interesa el potencial que tiene para tareas de visualización. Propor-
ciona muchas funcionalidades básicas para modificar la visualización de un grafo, como
modificar la posición de los nodos, cambiar propiedades básicas de los nodos y las aristas
(color, tamaño, etiqueta, etc). Además ofrece la posibilidad de aplicar de manera interac-
tiva sobre un grafo ciertos algoritmos que simulan fuerzas de atracción y repulsión entre

14



UCM

los nodos, conocidos como algoritmos de distribución (o layout en inglés), que sirven de
utilidad para modificar la forma en la que se ordenan los nodos en función de ciertas
variables. Sobre estos algoritmos hablaremos más adelante.
En la Figura 2.6 se muestra la interfaz de Gephi con una visualización de una red de
ejemplo.

Figura 2.6: Interfaz gráfica de Gephi

NetworkX

NetwrokX es una librería de Python diseñada para el análisis y la exploración de re-
des [10]. Proporciona métodos para construir grafos y operar con ellos. También permite
generar visualizaciones de estos, apoyándose en una conocida librería de python para
generar gráficas: Matplotlib [13]. Las visualizaciones generadas a través de esta librería
son mucho más limitadas que las que proporciona Gephi, pero a cambio permite realizar
todo el proceso desde construir un grafo hasta mostrarlo por pantalla desde el código.
Además implementa algunos algoritmos de fuerzas para aplicar a los grafos aunque no a
tiempo real.

15



UCM

Figura 2.7: Ejemplo de grafo construido y visualizado usando NetworkX

PyVis

PyVis es otro módulo de Python centrado en la visualización y la manipulación inter-
activa de de grafos [24]. A diferencia de Gephi y NetorkX se centra únicamente en la
visualización y no ofrece otras funcionalidades como construir grafos, realizar cálculos
sobre ellos, etc.
A través de esta librería se pueden generar visualizaciones directamente desde el código
y modificar factores de los nodos y las aristas como el color, el tamaño, etc. Además es
capaz de trabajar con grafos previamente construidos con NetworkX. También propor-
ciona varios algoritmos de distribución y permite aplicarlos en tiempo real al igual que
Gephi.

Figura 2.8: Ejemplo de visualización de un grafo con PyVis

16



UCM

2.3.2. Algoritmos de distribución de grafos

Para que una visualización de un grafo aporte información sobre este no basta con dibujar
los nodos y las aristas, también es importante la manera en la que se distribuyen los
nodos para aportar claridad a la visualización y reflejar de manera visual las relaciones
que existen entre ellos.

Existe una serie de algoritmos que aplican distintos métodos para distribuir los nodos de
un grafo de múltiples formas. Los más relevantes dentro de este campo son los algoritmos
que simulan una serie de fuerzas entre los nodos para modificar su posición, conocidos co-
mo algoritmos guiados por fuerzas (o force-directed algorithms en inglés). En esta sección
vamos a mencionar dos de los más utilizados y que pueden ser de utilidad más adelante,
a la hora de generar visualizaciones de los datos.

Algoritmo Fruchterman-Reingold

El algoritmo Fruchterman-Reingold [9] trata a las aristas de un grafo de manera análoga
a un muelle físico, atrayendo a los nodos que interconectan, y a su vez aplica a todos los
nodos una fuerza de repulsión que los separa entre sí. Este proceso lo realiza de manera
iterativa, tratando de minimizar la “energía” del sistema [12].
Este método normalmente resulta en grafos con aristas similares en tamaño y con los
nodos en una estructura circular donde aquellos con más conexiones quedan en el centro
y aquellos con menos conexiones quedan en las afueras.

En la Figura 2.9 se puede ver el resultado de aplicar este algoritmo a un grafo de ejemplo,
utilizando la implementación de este algoritmo proporcionada por Gephi. NetworkX tam-
bién ofrece una implementación propia que puede servir de alternativa si no se pretende
usar Gephi para la visualización de los datos.

Figura 2.9: Ejemplo de aplicar Fruchterman-Reingold a un grafo

17



UCM

Algortimo ForceAtlas2

El algoritmo ForceAtlas2 [14] es el algoritmo utilizado por defecto en Gephi. En esen-
cia es un método similar a Fruchterman-Reingold, ya que aplica una fuerza de repulsión
entre los nodos y una fuerza de atracción a partir de las aristas, sin embargo la manera
de calcular y aplicar estas fuerzas es distinta. Como resultados, este método obtiene una
distribución de los nodos que tiene más en cuenta el peso de las aristas, permitiendo
representar mejor las relaciones que existen entre los nodos.
La implementación original de este algoritmo solo puede encontrarse en Gephi, sin em-
bargo existen algunas librerías de Python como la librería ForceAtlas2 [27], que ofrece
una adaptación de la implementación de Gephi para aplicarla sobre redes construidas con
NetworkX.

En la Figura 2.10 se puede ver el resultado de aplicar este algoritmo al mismo grafo de
ejemplo de la Figura 2.9, usando de nuevo Gephi para ello.

Figura 2.10: Ejemplo de aplicar ForceAtlas2 a un grafo

2.4. Resumen del capítulo

En este capítulo hemos revisado varios de los distintos métodos y herramientas, existentes
actualmente, en los que podemos apoyarnos para llevar a cabo los objetivos del proyecto.
Pero antes de terminar, es de utilidad hacer un pequeño resumen para para establecer
cómo se aplicará todo la información aquí expuesta en el desarrollo del proyecto.

En cuanto a las medidas de similitud explicadas, estas son las más utilizadas en el campo
de la inteligencia artificial y el machine learning, sobre todo la distancia Euclidiana y
la similitud del coseno, pero en nuestros casos de uso, al utilizar en su gran mayoría
atributos nominales u ordinales, no utilizaremos ninguna de ellas y definiremos medidas
de similitud más adecuadas al tipo de atributos con los que trabajamos.

18



UCM

Por otro lado, para resolver el problema de dividir los datos en comunidades utilizaremos
técnicas de clustering, una de las herramientas de aprendizaje automático no supervisado
más utilizadas. No existe un único algoritmo de clustering que se pueda utilizar univer-
salmente para todos los tipos de datos, pero las categorías de algoritmos más utilizados
son los de partición, jerárquicos y los basados en densidad. Para realizar la prueba de
concepto de este trabajo, hemos decidido hacer la experimentación usando un algoritmo
de cada tipo: K-medoids, agglomerative y DBSCAN.

Por último, la manera más utilizada para llevar a cabo la visualización de las comunidades
es mediante el uso de grafos. Existen multitud de herramientas diseñadas para esto.
En este trabajo haremos uso de Gephi para realizar las primeras pruebas, pero para la
implementación final se usará un método de visualización que no requiera de programas
externos y se pueda ejecutar directamente desde el código, como PyVis. Además, se usarán
algoritmos de distribución de grafos guiados por fuerzas para modificar la posición de los
nodos y mejorar así la interpretabilidad de las visualizaciones.

19



Capítulo 3

Desarrollo de la arquitectura

La arquitectura que se va a desarrollar a lo largo de este proyecto ha de ser capaz de llevar
a cabo varias funcionalidades para lograr generar todo lo establecido en los objetivos, es
así que primero será preciso estudiar como realizar cada uno de ellos. La meta final es
definir como funcionará el flujo de trabajo, donde partiendo de unos datos iniciales, se
vayan generando los artefactos necesarios para obtener finalmente las comunidades junto
con su explicación y visualización correspondientes.
Cada una de las funciones a realizar en la arquitectura para llegar al objetivo final se
pueden separar en distintas etapas. En este capítulo estableceremos cuáles serán estas
etapas y explicaremos en que consistirán y qué operaciones se llevarán a cabo en cada
una de ellas. En la Figura 3.1 se puede ver un diagrama general de estas etapas y cómo
se han de conectar entre sí.

Figura 3.1: Estructura básica del flujo de trabajo de la arquitectura a desarrollar

3.1. Caso de uso: Museo del Prado

Los datos a utilizar son una parte fundamental para todo el desarrollo expuesto en este
capítulo, siendo de gran importancia comenzar hablando de como serán estos, antes de
continuar con el resto de apartados.
Como comentábamos en la introducción, el caso de uso de la arquitectura a desarrollar

20



UCM

estará comprendido dentro del ámbito de las visitas a museos. Entrando más en detalle,
los datos con los que trabajaremos representarán a un grupo de visitantes de un museo (a
los que a partir de ahora nos referiremos como usuarios) que han expresado las distintas
emociones que han sentido durante su visita al ver cada una de las obras expuestas en
el museo, o un conjunto reducido de ellas. Además de la relación entre los usuarios y las
obras a través de las emociones, en los datos se recogerán una serie de características
principales de los usuarios y las obras.
Dentro de este caso de uso, cualquier conjunto de datos, procedan del museo o la exposi-
ción que sea, servirá para llevar a cabo las tareas de detección de comunidades, explicación
y visualización para las que la arquitectura estará diseñada. Sin embargo, es importante
establecer como deberá ser la estructura de los datos, para que puedan ser utilizados
vengan de donde vengan.

3.1.1. Datos

Los primeros datos a los que hemos tenido acceso para poder realizar las pruebas iniciales,
han sido proporcionados por los directores del proyecto. Estos datos han sido generados
sintéticamente para el proyecto SPICE [2] y contienen información de varios usuarios que
han visitado el Museo del Prado, un conjunto de obras de este museo y una serie de
emociones que los usuarios han sentido al ver las obras. Estos datos nos van a permitir
entender qué información será relevante para desarrollar el proyecto y nos servirán para
realizar todas las pruebas pertinentes.

A continuación resumimos los tres tipos de datos con los que trabajaremos y su conteni-
do:

Datos de usuarios: Datos demográficos de un grupo de 171 visitantes del Museo
del Prado. Representados por un identificador, su edad, género y país de proceden-
cia.

Datos de obras: Información sobre 30 obras distintas (concretamente cuadros)
expuestas en el Museo del Prado. Recopila datos básicos de cada obra como el
autor, la corriente artística a la que pertenecen o el año de su creación, así como
enlaces a distintas fuentes de información adicional como imágenes de cada obra o
información de esa obra en la plataforma de WikiData. Además cada cuadro tiene
asociado un identificador.

Datos de interacciones: Datos con 1760 interacciones que relacionan a los usua-
rios con las obras en base a las emociones que los primeros han sentido al ver cada
una de las obras. Se recoge tanto el tipo de emoción (miedo, tristeza, sorpresa, etc)
como la polaridad de estas, es decir si se considera una emoción positiva, negativa
o neutra. En este caso, solo tendremos en cuenta los datos de polaridad para saber
si a un usuario le ha gustado (polaridad positiva), disgustado (polaridad negativa)
o le ha dejado indiferente (polaridad neutra) una obra.

21

https://www.wikidata.org/wiki/Wikidata:Main_Page


UCM

Estructura básica de los datos

Basándonos en la estructura ya existente en estos datos del Museo del Prado, hemos
definido una estructura básica que deberán seguir los datos para poder trabajar con
ellos.

La estructura definida no difiere demasiado de la ya existente en estos datos, variando,
simplemente, el lugar de aparición de los datos de las emociones, que en lugar de encon-
trarse en un fichero a parte se trasladan directamente a los datos de los usuarios como un
atributo más. Ahora cada usuario estará representado, a parte de por sus datos demográ-
ficos, por tres listas de obras: una con las que le han provocado emociones positivas, otra
con las que le han provocado emociones negativas y otra con las que le han provocado
emociones neutras. Además, cabe destacar que un usuario solo tendrá un tipo de emoción
para cada cuadro, en los datos del Museo del Prado los usuarios podían tener más de una
emoción hacia un mismo cuadro, por lo que para establecer la polaridad de un usuario
hacia un cuadro calculamos la polaridad media de todas las emociones que tiene hacia
ese cuadro. Por otro lado los datos de las obras permanecen intactos.

Este trabajo de modificación de la estructura de los datos del Museo del Prado para
adecuarse a esta estructura básica se ha considerado un trabajo de preprocesado, dando
por sentado que cualquier otro conjunto de datos distinto que se quiera utilizar ya estará
construido en base a esta estructura.

Figura 3.2: Ejemplo de la estructura básica de los datos aplicada al caso de los usuarios
del Museo del Prado

22



UCM

Figura 3.3: Ejemplo de la estructura básica de los datos aplicada al caso de las obras del
Museo del Prado

Esta estructura básica, definida y ejemplificada a partir de los datos del Museo del Pra-
do (Figuras 3.2 y 3.3), permitirá que cualquier nuevo conjunto de datos procedente de
otras fuentes, se pueda utilizar dentro de la arquitectura siempre que mantenga esta
estructura.

3.2. Modelado de comunidades

Partiendo de unos datos con información básica de varios usuarios, cualquier persona, a
simple vista, podría agruparlos en base a distintas características: agrupar a todos los
usuarios de un mismo género, todos los de una misma edad, etc. Pero si se empiezan a
tener en cuenta varias de estas características a la vez, el proceso comienza a complicarse
y las relaciones entre usuarios con varias características en común son cada vez menos
explícitas. Por este motivo, es interesante buscar relaciones implícitas dentro de los datos
y ver cómo pueden usarse estas para agruparlos entre sí.

Los algoritmos de clustering son un método perfecto para conseguir esto, encontrando
patrones dentro de unos datos que a priori no están clasificados de ninguna manera. Este
proceso lo llevan a cabo calculando como de similares son todos los individuos entre si y
separándolos en distintos clusters en base a esas similitudes obtenidas.

Para poder determinar si dos individuos son similares es necesario definir algún tipo de
medida que lo establezca. Generalmente los algoritmos de clustering tratan a los indivi-
duos como puntos en un espacio n-dimensional (siendo n el número de atributos de estos
individuos) y aplican alguna medida de distancia, como puede ser la distancia euclídea,
para calcular como de cerca están y por tanto como de similares son dos individuos. Sin
embargo para este caso en concreto estas medidas pueden resultar muy generalistas, esto
nos lleva a considerar que es interesante definir una forma de calcular la similitud más
específica para este dominio, en la que se aplique un conocimiento previo del mismo para
afinar el cálculo de las similitudes.

23



UCM

3.2.1. Similitud entre usuarios

Queremos definir una medida de similitud que relacione a los usuarios entre sí. Dentro de
los datos cada usuario está caracterizado por una serie de atributos así que estableceremos
la similitud entre los usuarios como la similitud entre cada uno de sus atributos, asignando
además a cada uno un peso entre 0 y 1 que denotará la importancia de este en el cómputo
final. Es importante tener en cuenta que la suma de los pesos de todos los atributos debe
ser siempre igual a 1, además el ajuste de que peso debe tener cada atributo es algo que en
este proyecto dejaremos como un parámetro más a modificar durante la configuración de
la arquitectura desarrollada, para perfeccionar este ajuste lo ideal sería que fuese realizado
por alguien con conocimiento experto sobre los datos utilizados, en el caso de los datos
del Museo del Prado podría ser un curador del museo con conocimiento de qué atributos
pueden ser de más importancia (lo que definimos en la sección 1.2 como “responsable del
museo”), o en su defecto, realizar el ajuste de una manera automática con algún tipo de
algoritmo.

Los atributos de los usuarios pueden separarse en dos tipos: datos demográficos y opinio-
nes sobre las obras. Queremos tener en cuenta ambos tipos pero cada uno nos proporciona
información distinta, por un lado los demográficos nos ayudarían a relacionar a los indi-
viduos por características más sociales y por otro lado las opiniones que los relacionarían
por características más individuales, ambas cosas son interesantes así que tendremos en
cuenta ambos tipos pero de manera separada.

Figura 3.4: Cálculo de la similitud entre usuarios mediante la similitud de sus atributos

Podemos definir entonces la similitud entre dos individuos como una suma ponderada de
la similitud entre los atributos demográficos y los gustos respecto a las obras de los dos
individuos. Como máximo puede llegar a obtener un valor de 1 si los dos usuarios son
idénticos y como mínimo un valor de 0 si los usuarios son totalmente diferentes.

(3.1)sim_usuarios = [(sims_atr_demog ∗ pesos_atr_demog) ∗ peso_demographic]
+ [(sims_atr_polar ∗ pesos_atr_polar) ∗ peso_polarity]

24



UCM

Con esta fórmula tenemos establecido cómo obtener la similitud global entre los usuarios
pero para poder ponerla en práctica es necesario establecer cómo calcular la similitud
individual entre los atributos.

Si lo que queremos es definir unas funciones de similitud específicas para cada atributo,
debemos tener en cuenta que podemos tener una gran variedad de estos y es posible que
para cada uno sea preciso buscar una forma de establecer su similitud distinta de los
otros atributos. Para esto lo que haremos es definir un pequeño catálogo de funciones de
similitud con distintas funciones para cada tipo de atributo.

Atributos demográficos

En primer lugar, hemos definido funciones de similitud para los atributos demográficos
genéricos como la edad, el país o el género:

Edad : Hemos definido dos posibles funciones de similitud para la edad para ver
como de cerca están dos valores dependiendo del formato en el esta se represente:

• Si están presentes en forma de intervalos (p. ej. 0-12, 18-24...) la función es:

simEdad(A,B) = 1− (
|A.edad−B.edad|
rangoEdades− 1

) (3.2)

donde rangoEdades es el número de intervalos de edad existentes en el dataset.

• Si están presente en forma de valor específico la función es:

simEdad(A,B) = 1− (
|A.edad−B.edad|

difEdad
) (3.3)

donde difEdad es el valor de restar el máximo valor de edad presente en el
dataset menos el menor valor presente.

Género: Igualdad simple, con un valor entre 0 y 1

simGenero(A,B) =

{
0, si A.genero ̸= B.genero

1, si A.genero = B.genero
(3.4)

País: Hemos definido dos posibles funciones de similitud para el país dependiendo
de como de preciso se quiera comparar:

• Si queremos ser ser muy precisos comparamos simplemente los países con una
igualdad. Solo devolverá 1 si son el mismo país y 0 para cualquier otro caso.

simPais(A,B) =

{
0, si A.pais ̸= B.pais

1, si A.pais = B.pais
(3.5)

• Si no queremos ser tan precisos podemos comparar la región en la que está el
país. Para eso, preprocesamos los datos gracias a un dataset de países y regiones

25



UCM

y devolvemos una igualdad entre las regiones de los dos países a comparar.

simRegion(A,B) =

{
0, si A.region ̸= B.region

1, si A.region = B.region
(3.6)

Atributos de gustos

Los atributos que representan los gustos de cada usuario son distintos a los atributos
demográficos. Aquí no tenemos valores individuales (numéricos o categóricos), tenemos
atributos cuyos valores representan listas de elementos que han provocado distintas emo-
ciones a los usuarios. Para cada usuario podemos obtener una lista de aquellas obras que
le han provocado emociones positivas, otra de aquellas que le han provocado emociones
negativas y otra de aquellas que le han provocado emociones neutras.

Figura 3.5: Formato en el que se representan los gustos de los usuarios sobre las obras

El método que hemos definido para calcular la similitud entre estas listas consiste en
comparar todas las obras que han provocado emociones positivas a un usuario con las
que han provocado emociones positivas a otro usuario (y repetir esto con las emocio-
nes negativas y las neutras). La forma más directa de hacer estas comparaciones sería
simplemente comprobar cuántos elementos tienen ambas listas en común, cuantos más
elementos más similares serán y viceversa, sin embargo esto solo tendría en cuenta obras
que hayan sido vistas por ambos usuarios ignorando el resto. Podemos perfeccionar esto
algo más. Puede que dos usuarios no compartan las mismas obras pero puede que haya
obras muy similares entre sí y que a pesar de no ser exactamente la misma podrían te-
nerse en cuenta para afinar más la similitud entre los gustos de los usuarios. Con esto
introducimos la necesidad calcular la similitud entre las distintas obras previo a poder
calcular la similitud entre los usuarios, así una vez tengamos la similitud entre las obras
podremos comparar las listas de gustos y calcular la media de todas las similitudes entre
todos los pares de obras.

Gustos: Dadas dos listas de obras L1 y L2, siendo L1 la lista de mayor tamaño, L2
la de menor y sim la matriz de similitud de las obras, calculamos la similitud entre
dos listas de obras de la siguiente manera:

simGustos(A,B) =

∑
i∈L1

(máx
j∈L2

(sim[i, j]))

|L1 ∪ L2|
(3.7)

26



UCM

3.2.2. Similitud entre obras

Como hemos explicado anteriormente, para calcular la similitud entre los gustos de los
usuarios calcularemos la similitud entre las distintas obras disponibles en los datos. Al
igual que los usuarios, las obras también vienen caracterizadas por unos atributos así que
haremos lo mismo que hemos hecho para los usuarios y calcularemos las similitudes de
las obras en base a las similitudes de sus atributos.

Vamos a crear otro catálogo igual al de los usuarios con funciones de similitud específicas
para los atributos genéricos que tendrán las obras en cualquier dataset.

Artista: Igualdad simple

simArtista(A,B) =

{
0, si A.artista ̸= B.artista

1, si A.artista = B.artista
(3.8)

Categoría (movimiento artístico en el que se identifica una obra): Igualdad simple

simCategoria(A,B) =

{
0, si A.categoria ̸= B.categoria

1, si A.categoria = B.categora
(3.9)

Colores: Para el caso de los datos del museo del prado proporcionados por los
directores del proyecto obtuvimos también un fichero JSON con información sobre
los colores predominantes de cada cuadro del dataset. Estos colores están repre-
sentados en codificación RGB, sin embargo con esta codificación del color no se
puede separar la información sobre el color y su luminosidad, lo que complica la
comparación de colores, pero existe otro formato, HSV, que separa la luminosidad
del valor del color y mejora la comparación de colores entre sí (podemos ver ambos
en la Figura 3.6).

Figura 3.6: Espacios de colores RGB y HSV [29]

Convirtiendo entonces los datos RGB a HSV podemos aplicar la función de la Figura
3.7 que calcula cómo de similares son dos colores con respecto a su valor HSV

27



UCM

Figura 3.7: Función de distancia entre dos colores en formato HSV [6]

En la Figura 3.8 podemos ver un esquema de cómo sería el proceso de calcular la similitud
entre dos cuadros con este método.

Figura 3.8: Cálculo de la similitud entre obras mediante la similitud de sus atributos

3.3. Clustering

Una vez calculada la matriz de similitud de los usuarios vamos a utilizar esa informa-
ción para dividir a nuestros usuarios en distintas comunidades dependiendo de cómo de
similares sean.

Los algoritmos de clustering utilizan métricas para medir la distancia entre dos puntos y
poder decidir si asignarlos al mismo cluster o no. Como ya hemos precalculado la similitud
de los usuarios podemos transformar directamente esa matriz a una matriz de distancias
(simplemente calculando su complementario) que podemos pasar a los algoritmos como
parámetro para que, en el momento de comparar dos usuarios, en vez de utilizar una fun-
ción de distancia como métrica (como por ejemplo la distancia Euclídea o Manhattan)
simplemente acceda al valor ya calculado en la matriz.
Una vez hecho esto hemos optado por utilizar el algoritmo K-medoids, aunque más adelan-
te existirá la opción de utilizar otros algoritmos como el Agglomerative, por dos motivos:
el elegir como puntos centrales (o medoides) a usuarios existentes en el dataset, en lu-
gar de elegir la media entre los puntos de todo el cluster como hacen algoritmos como

28



UCM

K-means, será más robusto frente a valores atípicos (Figura3.9) y además facilitará la
interpretación de los datos finales.

Figura 3.9: Representación visual de centroide y medoide. (Imagen sacada de referencia
[7])

Para calcular el número de clusters óptimos utilizamos la medida Davies Bouldin[5].
Esta medida se utiliza para evaluar la separación media entre los clusters que ha generado
el modelo. Al querer generar la máxima separación de clusters, la medida que se obtiene
calculando la similitud media entre los clusters (comparando la distancia entre clusters
con el tamaño de dichos clusters), tiene un valor mínimo de cero y cuanto menor sea
indicará una mejor partición. Esta medida se calcula varias veces con distinto número de
clusters para posteriormente poder escoger el número de clusters con menor valor.
En la Figura 3.10 se muestra una gráfica de ejemplo donde el eje horizontal representa el
número total de clusters (k) y el vertical el valor del índice de Davies Bouldin [5]. Este
índice varía a medida que aumenta k y alcanza su valor mínimo para k = 5, indicando
entonces que 5 sería el número óptimo de clusters en los que se deberían dividir los
datos.

Figura 3.10: Variación del índice Davies Bouldin al aumentar la cantidad de clusters

29



UCM

Una vez calculado el número de clusters óptimos y elegido el algoritmo de clustering se
procede a clasificar los usuarios en diferentes grupos usando las similitudes calculadas
previamente

3.4. Explicación y visualización

Finalmente, teniendo los datos de los usuarios ya agrupados en distintas comunidades,
el último paso que queremos llevar a cabo es entender mejor los motivos para que estas
se hayan generado de esta forma y qué representa cada una de ellas. Para esto vamos
a entrar más en detalle en cómo generaremos las explicaciones y visualizaciones de los
datos.

3.4.1. Explicación

Tras aplicar un algoritmo de clustering a los datos obtenemos una clasificación de los usua-
rios en distintas comunidades, con cada comunidad englobando a un grupo de usuarios
con características similares (entendiendo que esa similitud está definida por las funciones
de similitud utilizadas). Con esta información ya podemos ver que usuarios se parecen
entre sí, pero al ser los algoritmos de clustering un método de aprendizaje no supervisado,
no podemos obtener mucha más información sobre que representa exactamente cada co-
munidad. Es por este motivo que surge un interés en llevar a cabo un proceso para poder
interpretar más en detalle cada comunidad y entender qué caracteriza a los usuarios que
la componen.

Esto lo podemos conseguir observando comunidad por comunidad los atributos de los
individuos que las componen. A partir de esto podemos llevar a cabo dos métodos. Por
un lado, podemos explorar los valores que toman los atributos de los usuarios de una
misma comunidad y ver cuál es la distribución de los valores y cuáles predominan en la
comunidad, con esto podemos generar una explicación que muestre estos datos, pudiendo
caracterizar a una comunidad por estos valores que predominan frente al resto.
Por otro lado, podemos calcular un valor medio para cada uno de los atributos, en el caso
de atributos nominales (género, intervalo de edad, etc) estos serán los que correspondan
con la moda de todos los valores, mientras que en el caso de atributos numéricos serán
los que correspondan con la media. A partir de estos valores medios, podemos generar
un individuo artificial, al que denominaremos “individuo explicador”, que generalice las
características de cada comunidad y sirva como un representante de esta. Podemos ver
un ejemplo básico, teniendo en cuenta solo dos atributos, de este individuo explicador en
la Figura 3.11

30



UCM

Figura 3.11: Ejemplo básico de la creación de un individuo explicador a partir de una
comunidad

3.4.2. Visualización

En cuanto a la visualización de las comunidades, el objetivo es poder ver representados
a todos los usuarios, cada uno identificado según la comunidad a la que pertenezca y
pudiendo ver la información pertinente de cada usuario.
La parte más relevante a la hora de visualizar los resultados no es solo ver gráficamente
cada comunidad y qué usuarios pertenecen a cada una. También es interesante observar
como se relacionan estas comunidades entre sí, o mejor dicho, como se relacionan los
individuos de las distintas comunidades entre sí. Gracias a que se ha calculado previa-
mente un valor de similitud para cada par de usuarios, podemos establecer una relación
directa entre ellos, representando esta información en forma de red, con los usuarios como
nodos y las conexiones entre cada par de ellos dependen de su similitud. Esta red sur-
gida de los usuarios y sus relaciones entre sí puede representarse en forma de grafo, con
esto podremos usar técnicas de visualización de grafos para poder mostrar finalmente las
comunidades.

Habiendo decidido representar los datos de los usuarios y sus comunidades en forma
de red, el primer paso es generar un grafo: A partir de los datos obtenidos en las fases
anteriores se generará un grafo donde los nodos corresponderán a cada uno de los usuarios
y cada nodo estará conectado al resto de nodos mediante aristas, que tendrán un peso
asignado en función de la similitud entre los dos nodos que conectan. El resultado de este
proceso será un grafo completo, donde todos los nodos están conectados con todos.
Con el grafo generado, queda modificar la disposición de los nodos para representar
de manera visual las similitudes, sin tener que comprobar manualmente el peso de cada
arista, de manera que cada nodo se dibuje más cerca de los nodos que tiene mayor similitud
y más lejos de aquellos con los que tiene una similitud menor. La manera de conseguir
esto es aplicando un algoritmo de distribución de grafos, como los explicados en el sub-
apartado 2.3.2, cuyo trabajo será simular fuerzas de atracción y repulsión entre todos los
nodos usando el peso de sus aristas como forma de aumentar o disminuir estas fuerzas
(cuanto más peso, mayor atracción y por tanto más cerca), modificando así la posición

31



UCM

de cada nodo en la visualización. Con esto obtendríamos una manera de visualizar que
usuarios son más similares entre sí, si además asignamos a cada nodo un color en función
de la comunidad a la que pertenece, podremos ver las relaciones que existen entre las
comunidades a partir de sus individuos.

Una vez establecido este proceso, podemos comprobar que funciona haciendo alguna prue-
ba de detección de comunidades y visualizando los resultados. Además, una prueba así
también nos sirve para comprobar que el calculo de las comunidades funciona bien, ya
que, por definición, los usuarios de una misma comunidad tendrán una mayor similitud
entre sí que con el resto de comunidades, por tanto , si todo funciona bien, en la visuali-
zación se debería ver a aquellos nodos de un mismo color más cercanos entre sí que con
el resto de nodos de otros colores. En la figura 3.12 podemos ver los resultados de una de
estas pruebas. Para ella se han generado una serie de comunidades en la que solo se ha
tenido en cuenta un único atributo, simplificando así el resultado para poder comprobar
a simple vista que todo ha funcionado como se esperaba. Usando los datos del Museo del
Prado, se ha calculado la similitud de los usuarios solo teniendo en cuenta su edad, dando
cómo resultado una comunidad por cada valor de edad existente en los datos (en este caso
existen nueve intervalos de edades y por tanto obtenemos nueve comunidades distintas).
Al visualizar esto se puede ver como, en efecto, existen nueve comunidades y además,
gracias al algoritmo de fuerzas aplicado, en este caso ForceAtlas2, están ordenadas de
forma que las comunidades más similares (aquellas correspondientes a intervalos de edad
cercanos) están más juntas.

Figura 3.12: Comunidad creada teniendo en cuenta solo la edad de los usuarios (visuali-
zación creada con Gephi)

32



UCM

Para visualizar estos resultados, como forman parte de una prueba, se han cargado en un
programa externo de visualización de grafos, Gephi. Este programa nos sirvió para realizar
las primeras pruebas de visualización ya que con solo cargar los datos de un grafo a través
de un fichero en el formato adecuado, permite aplicar todo tipo de transformaciones a
este. Sin embargo, el hecho de que sea un programa externo en el que hay que cargar y
modificar los datos de manera manual implica que no sirve para la implementación de
la arquitectura desarrollada en este proyecto, así que para las visualizaciones finales se
usarán otras librerías de Python para la visualización de grafos sin necesidad de programas
externos. Los resultados finales de la etapa de visualización de pueden ver más en detalle
en el siguiente capítulo.

33



Capítulo 4

Descripción funcional de la
arquitectura

En el capítulo anterior hemos establecido las fases del flujo de trabajo a seguir para
conseguir las comunidades de usuarios junto con su explicación y visualización. A partir de
estas fases hemos implementado una arquitectura compuesta por varias clases, cada una
encargada de llevar a cabo el trabajo una de las fases. También hemos desarrollado una
interfaz sencilla que permite ejecutar el flujo de trabajo de principio a fin, sin necesidad
de utilizar código, para facilitar el uso de la arquitectura por cualquiera de los usuario
de los definidos en la sección 1.2 y sobretodo por el usuario “responsable del museo” que
podrá modificar seleccionar atributos y modificar los pesos de la forma que considere más
correcta. En la Figura 4.1 podemos ver un diagrama que ilustra de manera sencilla estas
clases y su interacción entre ellas.

Figura 4.1: Diagrama con la interconexión entre las distintas clases que implementan el
flujo de trabajo

Con todo esto establecido, en este capítulo se explicará más en detalle cómo se ha realizado
la implementación y de qué manera puede utilizarse para poder obtener resultados.

34



UCM

4.1. Interfaz de usuario

En cada fase del proceso para obtener las comunidades y sus explicaciones hay varios
parámetros que pueden variar, como pueden ser las distintas funciones de similitud a
aplicar, el peso de cada uno de los atributos a la hora de calcular la similitud, que
algoritmo de clustering usar, etc. Por este motivo, se ha implementado una pequeña
interfaz que permite poder usar la arquitectura de forma manual, sin tener que acceder
al código, permitiendo introducir los datos necesarios y modificar los parámetros de cada
una de las fases para ir obteniendo los resultados.

Mientras que el código de cada fase estará implementado en Python puro, la interfaz la
implementaremos en Jupyter [18], una plataforma web que permite la ejecución de código
Python de manera interactiva utilizando ficheros a los que llama Notebooks, ayudándo-
nos además de la librería iPyWidgets[15] que permite la creación de elementos HTML
interactivos (widgets) dentro de un Notebook de Jupyter. Con esto podremos ejecutar el
código de cada fase desde Jupyter e ir introduciendo los datos y modificando los pará-
metros usando los widgets. El código de la interfaz se encuentra en la clase GUI.py y el
Notebook para ejecutarla directamente es Interfaz.ipynb

En lugar de hablar más de la interfaz en este apartado, explicaremos como hemos imple-
mentado las distintas partes de esta en los siguientes apartados, donde hablaremos de la
implementación de cada fase del flujo de trabajo de la arquitectura.

4.2. Generación de matrices de similitud

Como comentábamos en el capítulo 3, el primer paso tras cargar los datos es calcular la
similitud entre todos los elementos, tanto usuarios como obras. Como la similitud de las
obras será necesaria para calcular después la similitud de los usuarios, calcularemos esta
primero.

En primer lugar creamos una “clase interfaz” (SimilarityFunctionInterface.py) para definir
el esquema básico de cualquier función de similitud que se quiera implementar. En ella
se especificará que cualquier función de similitud ha de recibir dos ID que identifiquen a
los dos elementos a comparar y ha de devolver un valor decimal comprendido entre 0 y 1
que represente esta similitud (siendo 0 ninguna similitud y 1 exactamente iguales).

Con esto establecido, implementamos en dos clases, una para las obras (SimilarityArt-
works.py) y otra para los usuarios (SimilarityUsers.py), las funciones de similitud ex-
plicadas en las secciones 3.2.1 y 3.2.1. A partir de estas clases tendremos la opción de
ejecutar las funciones de similitud deseadas desde otras partes del código.

Las funciones de similitud calculan la similitud entre dos usuarios, para pasar los datos
de similitud al algoritmo de clustering será necesario agrupar las similitudes de todos
los pares de usuarios. La manera de conseguir esto es usando una matriz de similitud,
una matriz cuadrada con una columna y una fila por cada uno de los elementos, donde

35



UCM

se almacenará la similitud entre cada par, dando lugar a una matriz con una diagonal
principal formada por unos y simétrica respecto a esta.

El cálculo de las matrices de similitud lo implementamos en dos clases, una para generar
la matriz de las obras (ArtworksMatrix.py) y otra para la de los usuarios (UsersMa-
trix.py). El proceso para calcular ambas matrices de similitud consiste en recorrer todos
los elementos y calcular la similitud entre sus atributos aplicando a cada resultado un
peso correspondiente, obteniendo así el valor final de similitud entre los elementos.

Para ilustrar mejor como son estas matrices de similitud podemos ver en ejemplo de una
generada a partir de varias obras: En la Figura 4.2 podemos ver cinco de las obras del
caso de uso del museo del prado y en la Figura 4.3 un ejemplo de matriz de similitud
entre ellas. En este ejemplo se puede observar como la obras 1 y 3 son las más similares
debido a que comparten autor y categoría, aunque estos resultados variarán en función
de las funciones de similitud y los pesos escogidos en cada caso.

Figura 4.2: 5 obras del Museo del Prado

Figura 4.3: Matriz de similitud entre 5 obras del Museo del Prado

Además, el uso de matrices de similitud permitirá que no solo se pueda realizar el clus-
tering con las funciones de similitud ya definidas sino que podrá usarse cualquier matriz
de similitud de los elementos aunque haya sido generada de manera externa.

36



UCM

4.2.1. Interfaz gráfica para calcular las similitudes

El primer paso es elegir los archivos, en formato csv, con los datos de los usuarios y los
datos de las obras, estructurados como se establecía en el punto 3.1.1. (Figura 4.4).

Figura 4.4: Selección de los datos a través de la interfaz

De los datos de las obras se cargan todos los atributos disponibles y se pueden ir añadiendo
aquellos que se quieran usar, asignándoles una función de similitud y un peso (teniendo
en cuenta que los distintos pesos deben sumar siempre 1). Con esto se procede a calcular
la matriz de similitud de las obras (Figura 4.5). También se puede establecer un nombre
de fichero para exportar la matriz resultante a un archivo csv.

Figura 4.5: Selección de los atributos a utilizar, las funciones de similitud y los pesos,
para las obras

Una alternativa al paso anterior es cargar directamente una matriz de similitud ya cal-
culada (Figura 4.6).

Figura 4.6: Selección de matriz de similitud de las obras

37



UCM

Igual que con los datos de las obras, se cargan los atributos de los usuarios disponibles
en los datos usados y se seleccionan los deseados, con la función de similitud, el peso (en
este caso los pesos de los atributos demográficos deben sumar 1 entre sí, y por otro lado
los atributos de los gustos deben sumar 1). Además, se puede seleccionar el peso que se
le dará a los atributos demográficos (demographic weight) y, en contraposición, el que se
dará a los aributos de gustos (polarity weight). (Figura 4.7)

Figura 4.7: Selección de los atributos a utilizar, las funciones de similitud y los pesos,
para los usuarios

De manera alternativa, podemos cargar directamente una matriz con las similitudes ya
calculadas. (Figura 4.8)

Figura 4.8: Selección de matriz de similitud de las obras

4.3. Formación de los clusters

Tras haber calculado la matriz de similitud de los usuarios, procedemos a utilizar un
algoritmo de clustering para dividir a los usuarios. La implementación utilizada ha sido
la procedente de la librería Sklearn [23] y de la librería Sklearn.extra[30]. Las librerías
han sido elegidas porque son estándar del Machine Learning en Python y ofrecen imple-
mentaciones de una gran variedad de algoritmos de clustering como los explicados en el
capítulo 2.

38



UCM

Para llevar a cabo los cálculos de esta fase se ha creado una clase que se ocupe de
todo lo relacionado con el cálculo de los clusters (UsersClustering.py), que recibe la ma-
triz de distancia de usuarios y que engloba dos tipos de métodos: métodos que ejecutan
técnicas de clustering y el método que implementa el índice Davies Bouldin para calcular
el número óptimo de clusters.

Los métodos de clustering devuelven una lista con el cluster al que pertenece cada usua-
rio. Hemos implementado dos funciones por el momento: K-medoids y Agglomerative.
Las implementaciones utilizadas reciben como datos la métrica o afinidad a utilizar, pre-
computed en nuestro caso y dependiendo de la función puede recibir más parámetros:
K-medoids recibe el número de clusters a dividir, el algoritmo a utilizar (hemos escogi-
dopam por ser el más preciso) y el método para la inicialización de los primeros medoides;
Agglomerative recibe la condición para terminar (o bien el número de clusters o el umbral
máximo para unir clusters) y el tipo de enlace (simple, completo o la media).

4.3.1. Interfaz gráfica para generar los clusters

Se cargan todas las funciones disponibles para realizar el clustering procedentes del ar-
chivo de clustering (cada una de ellas implementa un algoritmo de clustering distintos).
Una vez escogido el método a utilizar, se generan los diferentes clusters.(Figura 4.9)

Figura 4.9: Selección de los algoritmos de clustering

4.4. Generación de las explicaciones

Una vez obtenidos los datos de los usuarios agrupados en distintas comunidades, se genera
a partir de ellos una explicación de cada comunidad. Este proceso está implementado en
una nueva clase (AverageUser.py) que contiene la lógica necesaria para generar las ex-
plicaciones. Hay dos funcionalidades principales en esta clase. Primero, podemos generar
para cada comunidad un individuo explicador a partir de los datos medios de todos los
usuarios. En segundo lugar, podemos obtener los datos más comunes de cada comunidad
y almacenarlos en un fichero JSON (ejemplo en la Figura 4.10) para después operar con
él y usarlo para generar cualquier tipo de explicación de las comunidades. Junto con los
datos de la explicación de manera textual se pueden generar también una serie de gráfi-
cas por cada atributo de los usuarios que representan la distribución de valores de cada

39



UCM

atributo en la comunidad. Toda esta información obtenida se utiliza para mostrar una
explicación detallada de cada comunidad.

Figura 4.10: Fichero JSON de ejemplo con los datos extraídos de una comunidad

4.4.1. Interfaz gráfica para generar las explicaciones

Antes de generar la explicación textual se da la opción de seleccionar qué atributos se
tendrán en cuenta. Si no se ha usado una matriz de similitud externa sino que se han
seleccionado los atributos a usar (Figura 4.5 y Figura 4.7), estos atributos elegidos ya
estarán seleccionados por defecto ya que si han influido en el calculo de las similitudes,
entonces han influido en la detección de comunidades y por tanto son relevantes para
entender de donde surge la comunidad. (Figura 4.11)

Figura 4.11: Selección de los atributos a usar en la explicación

Tras esto se genera una pestaña por cluster con toda la explicación, detallando la moda
y distribución de los valores de los atributos seleccionados, así como los cuadros que más
se repiten por cada polaridad. En la Figura 4.12 se muestra un ejemplo de cómo se vería

40



UCM

una explicación de una comunidad cualquiera: Podemos ver el número de individuos que
forman parte de ella; los valores predominantes para cada uno de los atributos elegidos,
en este caso vemos como los usuarios tienen en su mayoría edades entre 18-24 y 45-54, son
todos de género femenino y más de la mitad son españoles; y los cuadros más gustados
por cada polaridad, con su título, artista, categoría e imagen.

Figura 4.12: Explicación de uno de los clusters resultantes

En esta explicación no solo se pueden ver los valores predominantes de cada atributo,
también podemos ver más en detalle la distribución de todos los valores existentes para
ese atributo, como vemos ejemplificado en la Figura 4.13.

41



UCM

Figura 4.13: Explicación con las graficas de distribucción de los distintos valores de un
atributo

4.5. Generación de la visualización

El último paso del flujo de trabajo es visualizar las comunidades obtenidas anteriormente,
para ello, a partir de los datos de los usuarios agrupados, creamos un grafo con la infor-
mación completa de todos los atributos de los usuarios. Todo esto se implementa en una
nueva clase (UsersGraph.py) que ofrece métodos para añadir nodos al grafo a partir de
los datos de los usuarios, añadir aristas a partir de los datos de una matriz de similitud
y aplicar el algoritmo ForceAtlas2 para distribuir los nodos según su similitud.

El grafo creado está compuesto por nodos que representan a cada uno de los usuarios
del conjunto de datos y por aristas que representan las relaciones entre los usuarios, con
un peso equivalente a la similitud entre cada par de ellos. Dado que todos los usuarios
tienen una similitud entre ellos existe una arista para cada par de nodos, por lo que
estaremos generando un grafo completo (en la implementación final el grafo resultante
no es realmente completo ya que aquellas aristas que tengan un peso igual a cero se
obvian y no se generan ya que su presencia aporta la misma información que su ausencia
y eliminarlas permite ganar algo de eficiencia al trabajar con el grafo).
Por último, se añaden también al grafo nodos extra para representar a cada uno de
los individuos explicadores generados al obtener las explicaciones y así poder visualizar
también una representación de los valores medios de cada comunidad.

42



UCM

4.5.1. Interfaz gráfica para la visualización de las comunidades

Figura 4.14: Botón para generar la visualización

Al comenzar el proceso para construir la visualización (Figura 4.14), se construye un
grafo a partir de los datos de la fase de clustering, utilizando la librería NetworkX [10].
Siguiendo el proceso explicado en el sub-apartado 3.4.2, se aplica sobre este grafo el
algoritmo ForceAtlas2 para separar las comunidades (usando la implementación de la
librería ForceAtlas2 [27]) y todo esto se pasa a los métodos de la librería PyVis [24] para
generar una visualización del grafo dentro del Notebook (ejemplo en la Figura 4.15) en la
que se puede ver a todos los usuarios, coloreados en función de su comunidad, también se
puede ver a los individuos explicadores de cada comunidad, diferenciados por tener forma
de rombo, y además se puede elegir un nodo para ver toda la información de este, estando
resaltados en negrita los atributos utilizados a la hora de hacer el clustering (Figura 4.16).
Cabe destacar las aristas son escondidas a la hora de mostrar la visualización, ya que no
aportan información visual relevante, pero aun así han sido tenidas en cuenta previamente
por el algoritmo de distribución utilizado.

Figura 4.15: Visualización de varias comunidades obtenidas

43



UCM

Figura 4.16: Visualización de la información de un nodo del grafo

44



Capítulo 5

Conclusiones y trabajo futuro

Para concluir esta memoria, en este capítulo haremos un resumen sobre el trabajo realiza-
do y una reflexión sobre los resultados, comentando que hemos aprendido y proponiendo
diferentes vías por las que se podría continuar el proyecto en un futuro.

5.1. Conclusiones

Gracias a este proyecto hemos sido capaces de crear una arquitectura que permite iden-
tificar comunidades entre un grupo de visitantes de un museo, dar una explicación a las
divisiones obtenidas y visualizarlas en forma de grafos. Dada la definición de comunidad
proporcionada en el capítulo 1 queríamos ser capaces de experimentar con las caracterís-
ticas que definen a una comunidad y definir diferentes medidas de similitud capaces de
modificar dichas comunidades.

Las comunidades que surgen con los datos sintéticos utilizados contienen mucho ruido al
combinar todos los atributos, tanto los demográficos como los gustos de los usuarios, ya
que la cantidad de datos del caso de estudio es bastante reducida y no permite formar
comunidades con un alto grado de diferenciación. En un caso real, para poder extraer in-
formación más relevante, sería necesario utilizar una mayor cantidad de datos de los cuales
pudiesen extraerse más relaciones entre los individuos y sus distintos atributos.

Hemos podido experimentar aplicando diferentes técnicas de clustering (algoritmos de
partición, jerárquicos y basados en densidad) y hemos observado que dependiendo del
algoritmo utilizado se han modificado los resultados considerablemente. Los algoritmos
utilizados han sido el K-medoids, el aglomerativo y el DBSCAN. También hemos podido
experimentar diferentes manera de visualizar los datos utilizando diferentes herramientas
como Gephi y Pyvis.
Cabe destacar que la arquitectura ha sido diseñada como una herramienta de experimen-
tación, capaz de modificar fácilmente los parámetros utilizados tanto para el clustering
como para la explicación como para la visualización con la finalidad de poder mostrar
diferentes divisiones de los datos proporcionados.

45



UCM

Por último, consideramos que hemos cumplido todos los objetivos propuestos inicialmen-
te.

Hemos definido diferentes medidas de similitud entre obras, investigando diferentes
maneras de poder compararlas.

Hemos establecido maneras de comparar usuarios teniendo en cuenta tanto sus
gustos como sus atributos personales y hemos ejecutado diferentes métodos de clus-
tering.

Hemos generado explicaciones de las divisiones resultantes ayudando a comprender
las razones de estas divisiones.

Hemos creado una interfaz para poder probar todas las funcionalidades de la arqui-
tectura.

5.2. Trabajo futuro

Aunque estamos satisfechos con la arquitectura que hemos creado y creemos que hemos
cumplido los diferentes objetivos propuestos, el trabajo puede seguir ampliándose de
distintas maneras:

En este proyecto se ha realizado una prueba de concepto utilizando únicamente
datos del Museo del Prado, pero sería interesante ampliar las pruebas con datos de
otros museos ya que la arquitectura lo permite (siempre que cumplan la estructura
básica definida en el apartado 3.1.1)

Los pesos asignados a cada atributo para las pruebas se han establecido siguiendo
un criterio personal, pero lo realmente interesante sería ponerse en contacto con
una persona experta en el dominio del museo correspondiente para obtener una
distribución de pesos más específica.

Se podrían definir más medidas de similitud entre obras y usuarios, aunque esto
dependerá de los atributos que aparezcan en los datos obtenidos.

La interfaz implementada permite utilizar la arquitectura creada y ejecutar todo
el proceso, aun así se podría implementar una interfaz más amigable para el usua-
rio, para que cualquier persona sin conocimientos informáticos pueda utilizar la
herramienta sin tener que ejecutarla desde Jupyter Notebook.

Después de todo el trabajo realizado podemos ver potenciales implementaciones de esta
arquitectura y creemos que puede ser utilizada para desarrollar herramientas o fomentar
actividades que generen un impacto positivo en la forma de realizar visitas culturales pu-
diendo involucrar más al visitante. Por ejemplo, realizar recomendaciones de nuevas obras,
autores, etc a los individuos de cada comunidad o realizar sesiones de discusión o debate
sobre obras relacionadas para fomentar la interacción entre individuos similares.

46



Capítulo 6

Trabajo Individual

6.1. Alberto García

Desde que comenzamos el trabajo he participado en todas las tareas del mismo tanto en
el estado inicial de organización del proyecto, como en la programación e implementación
y en la documentación del proceso llevado a cabo.

Mis conocimientos sobre Machine Learning y el problema de división en comunidades
estaban limitados a lo aprendido en otras asignaturas por lo que los primeros meses
estuve gran parte del tiempo documentándome sobre diferentes conceptos como medi-
das de similitud o las diferentes técnicas de clustering existentes. Posteriormente estuve
familiarizándome con los datos del caso de prueba que teníamos, investigando posibles
implementaciones de medidas de similitud con los datos.

Para comenzar a hacer las primeras pruebas utilizando los datos del Museo del Prado era
necesario llevar a cabo un pre-procesamiento de estos datos del cuál me encargué. A partir
de aquí, investigué diferentes maneras de implementar una medida de similitud entre
países, llegando a encontrar el dataset con los países del mundo y las regiones a las que
pertenece, para luego desarrollar una medida de similitud de regiones. Aparte desarrollé
las funciones de similitud de edades, tanto la función por intervalos como la función con
valores continuos, y la función de similitud entre listas de cuadros con similitud entre los
cuadros ya precalculada investigando previamente sobre diferentes maneras de comparar
dos vectores de objetos como la similitud del coseno.

A la hora de desarrollar las clases de Python que implementan las funcionalidades de la
arquitectura me encargué de programar el código de la clase AverageUser.py, encargada
del cálculo de los individuos explicadores, crear un json con la información de la expli-
cación y generar distintos diagramas de la distribución de los atributos en los clusters.
En el resto de las clases colaboré programando y revisando las partes escritas por mi
compañero.

47



UCM

A la hora de la implementación de la interfaz he escrito el código de la clase encargada
de la explicación de los clusters obtenidos y la generación de imágenes, estadísticas y
diferentes widgets.

Con respecto a la memoria participé de forma directa o indirecta en todos los apartados
escribiendo, completando o revisándolos una vez escritos por mi compañero. Específica-
mente me centré más en los siguientes apartados:

Estado del arte: en el capítulo del estado del arte escribí los apartados sobre
medidas de similitud y sobre técnicas de clustering. Para ello investigué sobre estos
temas en diferentes fuentes relacionadas con ellas.

Desarrollo de la arquitectura: en el capítulo del desarrollo de la arquitectura
participé en todos los apartados junto a mi compañero, revisando y corrigiéndonos
mutuamente.

Descripción funcional de la arquitectura: en el capítulo de la descripción
funcional de la arquitectura escribí varios sub-apartados como la generación de
matrices de similitud y revisé el capítulo completo.

Conclusiones: en el apartado de las conclusiones redacté los resultados y las con-
clusiones que sacamos de todo el proceso y puse por escrito lo puesto en común
para el apartado del trabajo futuro.

Traducciones: finalmente me dediqué a traducir al inglés los apartados de la intro-
ducción y las conclusiones. Además revisé la traducción realizada por mi compañero
y corregí errores.

6.2. Pablo Daurell

A lo largo de todo el proyecto he trabajado en todas las tareas que se han ido llevando
a cabo de manera conjunta con mi compañero, estableciendo los distintos pasos a seguir
para realizar las tareas, desarrollando el código tanto de las primeras pruebas como de la
arquitectura final y redactando la documentación del proyecto en esta memoria.

Durante los primeros meses, cuando comenzamos a establecer las bases del proyecto, la
mayoría del trabajo realizado consistió en leer e informarme sobre técnicas de inteligencia
artificial y aprendizaje automático, principalmente para adquirir un mayor conocimiento
sobre los métodos de aprendizaje no supervisado (en concreto, las técnicas de clustering).
Sumado a esto, investigué sobre el caso de uso en el que íbamos a trabajar para familiari-
zarme con él y poder definir mejor los objetivos que buscaríamos en este proyecto.

Para visualizar los resultados obtenidos en las primeras pruebas, me centré en utilizar la
herramienta Gephi. Para ello investigué una manera para conectar el Notebook de Jupyter
a Gephi a través de la cuál podía enviar un grafo generado en Python a Gephi para
visualizarlo allí. A raíz de esto también investigué sobre los algoritmos de distribución

48



UCM

de grafos basados en fuerzas, ya que Gephi ofrecía varias implementaciones de estos.
Todo este trabajo sirvió para comprobar que la detección de comunidades funcionaba
correctamente y nos facilitó la implementación final del módulo de visualización en el que
sustituimos el uso de Gephi por PyVis.

Para la parte de desarrollar las clases de Python donde se implementan todas las funcio-
nalidades de la arquitectura, yo me encargué de desarrollar la estructura de las funciones
de similitud para poder implementarlas en las clases de SimilarityArtworks.py y Similarit-
yUsers.py y también desarrollé por mi cuenta la clase UsersGraph.py donde se encuentra
el código para generar el grafo de usuarios y aplicarle un algoritmo de distribución. El res-
to del código fue desarrollado en colaboración con mi compañero, escribiendo y revisando
todo entre ambos.

Para terminar con la parte del código, me encargué de desarrollar la clase que implementa
la interfaz gráfica, escribiendo el código para crear los diferentes widgets con los que el
usuario puede interactuar y para conectar los resultados obtenidos de cada fase para
conseguir un flujo de trabajo funcional.

Con respecto a la memoria participé de forma directa o indirecta en todos los apartados
escribiendo, completando o revisándolos una vez escritos por mi compañero. Además
dibuje varias de las imágenes y diagramas presentes en varios capítulos. Específicamente
me centré más en los siguientes apartados:

Resumen: redacté el resumen inicial del proyecto y también lo traduje para el
abstract.

Introducción: en este capítulo introductorio, investigando distintos libros sobre
la materia y artículos del proyecto SPICE, redacté los apartados de motivación,
objetivos y estructura.

Estado del arte: en este capítulo me centré en escribir el apartado sobre las
técnicas de visualización de grafos, para lo que investigué sobre las distintas he-
rramientas y algoritmos existentes buscando en distintas páginas webs y artículos.
También revisé los otros dos apartados de este capítulo, haciendo algunos cambios
menores.

Desarrollo de la arquitectura: en el capítulo del desarrollo de la arquitectura
colaboré en redactar todos los apartados junto a mi compañero además de revisarlos
y corregirlos entre los dos.

Descripción funcional de la arquitectura: en este capítulo redacté la mayoría
de los apartados y tomé varias imágenes de los resultados obtenidos al usar la
interfaz para ilustrar lo contado.

49



UCM

Conclusiones: para este capítulo hice una revisión de lo escrito por mi compañero
y añadí pequeños cambios.

Traducciones: revisé las traducciones de la introducción y las conclusiones reali-
zadas por mi compañero y corregí algunos errores.

50



Capítulo 7

Introduction

To start discussing more in detail the project, in this chapter we will introduce the main
theme of the project, the motivations to carry it out and what objectives and tasks have
to be pursued to achieve everything proposed.

All the code written during the project can be found in the following github repository:
https://github.com/AlbertoGarciaDomenech/Comunidades-en-museos

7.1. Motivation

Museums are fundamental in the promotion of cultural heritage among the population.
However, over the last decades, the number of people visiting museums has decreased.
To counteract this, museums and other cultural institutions have taken several measures
to encourage people to visit museums. One of these measures is to make the public more
involved in the different activities and exhibitions offered by museums [28] and to have
them built not only on the museums decisions but also listening to the visitors opinion.
The SPICE project [2] is a project that explores this idea by grouping visitors into com-
munities from which they can make recommendations for new content and help visitors
build a representation of themselves to better understand their tastes and interests. But
what do we mean by grouping visitors into communities?

A community is a group of people with common characteristics, opinions, values, goals
or role in society. Within a set of people, multitude of common characteristics can be
found amongst them. Based on these characteristics relationships can be established
between people to form communities of similar individuals. Detecting these communities
helps build a higher level structure of the data of a set of individuals, simplifying the
comprehension of the relationships and facilitating the extraction of knowledge about the
data[25].

The process to model these communities can be done by taking into account a multitude
of factors and can be relatively simple if only a reduced set of factors are considered.

51

https://github.com/AlbertoGarciaDomenech/Comunidades-en-museos


UCM

Nonetheless, as the number of factors increases the task becomes more complicated but
at the same time the relationships found between individuals become also more complex
and the communities obtained can provide more insightful information.

There are different methods to detect communities within a dataset, methods capable
of taking into account a large number of characteristics from different individuals and
finding implicit relationships between them through which a series of sets of individuals
can be established. However, these methods operate in an opaque way for the user,
providing as a result of their execution a way of grouping the data without explaining
which characteristics have been considered to form each group.

Taking all of these into account and based on the ideas established in the SPICE project
[2] this project will design and implement a software architecture that will allow the use
of community detection methods to group visitors from a museum and will try to solve
the lack of transparency of these methods through techniques to interpret the results and
generate explanations and visualizations of these that are easily interpretable by anyone
outside the inner workings of the community detection methods.

7.2. Objectives

The main objective is to develop a reusable architecture to analyse the behaviour of
the visitors from a museum. To achieve this the architecture will have to be able to:
load data with characteristics of museums visitors, artwork exhibit in the museum and
the emotions the visitors feel with respect to these artworks; group visitors with similar
characteristics and emotions into communities (being able to use different methods to
obtain these similarities) and finally, offer tools to explain and visualize the communities
obtained, facilitating their interpretation.

To achieve this objective we have defined the following specific objectives during the
development of the project:

First objective: Define several similarity measures between artworks, and then
take their similarity into account when calculating the similarity between visitors
so as to detect communities with visitors with similar preferences.

Second objective: Establish a method to calculate how similar two individuals are
based on their demographic traits and their tastes they have for the different art-
works, in order to be able to apply clustering techniques based on these similarities
to group the visitors into different communities.

Third objective: From each community obtained, generate an explanation that
characterises the individuals that form it based on their common attributes and
helps understanding the logic behind its formation. Also explore different ways to
visualize the communities.

52



UCM

Fourth objective: Create an interface that helps end users to use all the functio-
nalities of the implemented architecture, enabling them to see and comprehend the
results obtained in the previous specific objectives. That, with some initial data, it
can perform the similarity calculations, group the individuals into communities and
generate the explanations and visualizations, allowing to modify the parameters of
each phase to generate different results.

7.2.1. Work plan

From the established objectives, we can specify a division into tasks for a better organi-
zation of the project development.

First objective:

• Task 1.1: Research and learn about the functioning of similarity measures.
• Task 1.2: Study and understand the data domain.
• Task 1.3: Define specific artwork similarity measures.
• Task 1.4: Review and test the performance of the defined measures.
• Task 1.5: Implement the generated code in a class of its own.

Second objective:

• Task 2.1: Study and understand the data domain.
• Task 2.2: Define a global similarity measure between users.
• Task 2.3: Define specific similarity measures for user attributes.
• Task 2.4: Review and test the performance of the defined measures.
• Task 2.5: Research and learn about existing clustering methods.
• Task 2.6: Test different methods of clustering.
• Task 2.7: Choose and apply clustering methods on the data.
• Task 2.8: Implement the generated code in a class of its own.

Third objective:

• Task 3.1: Study the results obtained when applying the methods of clustering.
• Task 3.2: Extract the common individual information from the different com-

munities obtained.
• Task 3.3: Explore ways of displaying and interpreting the information.
• Task 3.4: Study and learn about different graph visualization tools and methods.
• Task 3.5: Generate a graph with the information and visualize it.
• Task 3.6: Implement the generated code in a class of its own.

Fourth objective:

• Task 4.1: Choose a way to implement an interface in Python.
• Task 4.2: Create an interface that allows data input and connects all the

generated code in the previous objectives to achieve a complete workflow.

53



UCM

7.3. Document structure

This document is divided into eight chapters, each with its own motive. The first chapter
introduces the subject of the project, the problems to be addressed and the objectives to
be achieved.

The second chapter will explain different methods to tackle the community detection
problem and different tools used for visualization tasks which may be useful for the
project development.

The third chapter will deal with the process followed to achieve each proposed objective,
the different decisions taken and the tools and techniques used.

The fourth chapter will explain more in detail how the decisions taken in the third chapter
have been implemented, the basic functionalities of the implemented interface and show
some results obtained by the architecture.

The fifth chapter will bring the development to a close by drawing conclusions from the
whole process and its results and will established how this project can be continued in
the future.

The sixth chapter will be dedicated to show the contributions and individual work of
both authors of the project.

Finally, the seventh and eighth chapter are the first and sixth chapter translated to
english respectively, in order to comply with the stipulated regulations that require the
introduction and conclusions to be both in spanish and english.

54



Capítulo 8

Conclusions and future work

In this section we will finish by recapitulating the work we have done and reflecting on
the results obtained. Finally, we will offer some possibilities for steps to take to continue
with this project.

8.1. Conclusions

This project has allowed us to create an architecture capable of identifying communities
among groups of museum visitors, offering an explanation of the communities formed and
visualizing them in the form of graphs. Given the definition for communities provided in
chapter 2 we wanted to be able to experiment with the characteristics that define them
and define different similarity measures capable of changing these communities.

The communities obtained with the synthetic data contain great quantity of noise when
combining all the attributes, both demographic and users polarities, since the amount of
data in the case study is quite limited and does not allow communities with higher degree
of differentiation to form. In a real case, in order to extract more relevant information, it
would be necessary to use a larger amount of data from which more relationships between
individuals and their different attributes could be extracted.

We have been able to review different clustering techniques (partition, hierarchical and
density-based algorithms) and have observed the difference in the results obtained de-
pending on the algorithm used. The algorithms used were K-medoids, agglomerative and
DBSCAN. We have also been able to try different ways of visualizing the data using
different tools such as Gephi and Pyvis.
It should be noted that the architecture has been designed as an experimentation tool,
abled to modify the parameters used for both the clustering and explanation as well as
the visualization in order to be able to show different partitions of the data provided.
Finally, we consider that we have fulfilled all the initial objectives:

55



UCM

We have defined differente similarity measures between artworks, studying different
ways to compare them.

We have created different ways of comparing users taking into account both their
tastes and their personal attributes. We have also executed different clustering
techniques.

We have generated explanations of the resulting communities in order to understand
the reasons of these divisions.

We have created an interface capable of showing all of the architecture’s functiona-
lities.

8.2. Future work

Even though we are satisfied with the architecture we have built and consider the objec-
tives we set have been met, the project can still grow in some aspects:

In this project, a proof of concept has been made using only data from the Museo
del Prado but it would be interesting to extend the tests with data from other
museums since the architecture allows it (as long as the data complies with the
basic structure defined in section 3.1.1).

The weights assigned for each attribute in every test have been established following
personal criteria but it would be really interesting to contact an expert in the domain
of the corresponding museum to obtain a more specific weight distribution.

More similarity measures between artworks and users could be defined, although
this will depend on the attributes that appear in the original data.

The implemented interface allows using the architecture and executing the whole
process, even though a more user-friendly application could be created in order to
allow any person without computer knowledge to use the tool without having to
run it from Jupyter Notebook.

To conclude, we think our architecture has the potential to be used to develop tools or
encourage activities that involves more the visitor and can generate a positive impact on
the way cultural visits are made. For example, it could be used for recommending new
titles,authors,etc. to individuals from each community or to hold discussions or debate
sessions on related artworks to encourage interaction between individuals from the same
community.

56



Bibliografía

[1] M. Bastian, S. Heymann y M. Jacomy, «Gephi: an open source software for ex-
ploring and manipulating networks,» en Proceedings of the international AAAI
conference on web and social media, vol. 3, 2009, págs. 361-362.

[2] L. E. Bruni y col., «Towards advanced interfaces for citizen curation,» 2020.
[3] J. Choi y H.-J. Kwon, «The Information Filtering of Gene Network for Chronic

Diseases: Social Network Perspective,» International Journal of Distributed Sensor
Networks, vol. 2015, págs. 1-6, sep. de 2015. doi: 10.1155/2015/736569.

[4] W. Commons, File:K-means convergence.gif — Wikimedia Commons, the free me-
dia repository, [Online; accessed 16-May-2022], 2020. dirección: https://commons.
wikimedia . org / w / index . php ? title = File : K - means _ convergence . gif & oldid =

448129674.
[5] D. L. Davies y D. W. Bouldin, «A Cluster Separation Measure,» IEEE Trans.

Pattern Anal. Mach. Intell., vol. PAMI-1, n.o 2, págs. 224-227, abr. de 1979.
[6] B. Díaz-Agudo, G. Jimenez-Diaz y J. L. Jorro-Aragoneses, «User Evaluation to

Measure the Perception of Similarity Measures in Artworks,» en Case-Based Reaso-
ning Research and Development, A. A. Sánchez-Ruiz y M. W. Floyd, eds., Cham:
Springer International Publishing, 2021, págs. 48-63, isbn: 978-3-030-86957-1.

[7] A. Entezami, H. Sarmadi y B. Razavi, «An innovative hybrid strategy for structural
health monitoring by modal flexibility and clustering methods,» Journal of Civil
Structural Health Monitoring, vol. 10, nov. de 2020. doi: 10.1007/s13349-020-

00421-4.
[8] M. Ester, H.-P. Kriegel, J. Sander, X. Xu y col., «A density-based algorithm for

discovering clusters in large spatial databases with noise.,» en kdd, vol. 96, 1996,
págs. 226-231.

[9] T. M. Fruchterman y E. M. Reingold, «Graph drawing by force-directed place-
ment,» Software: Practice and experience, vol. 21, n.o 11, págs. 1129-1164, 1991.

[10] A. Hagberg, P. Swart y D. S Chult, «Exploring network structure, dynamics, and
function using NetworkX,» Los Alamos National Lab.(LANL), Los Alamos, NM
(United States), inf. téc., 2008.

[11] J. Han, J. Pei y M. Kamber, Data mining: concepts and techniques. Elsevier, 2011.
[12] D. Hansen, B. Shneiderman y M. A. Smith, Analyzing social media networks with

NodeXL: Insights from a connected world. Morgan Kaufmann, 2010.
[13] J. D. Hunter, «Matplotlib: A 2D graphics environment,» Computing in Science &

Engineering, vol. 9, n.o 3, págs. 90-95, 2007. doi: 10.1109/MCSE.2007.55.

57

https://doi.org/10.1155/2015/736569
https://commons.wikimedia.org/w/index.php?title=File:K-means_convergence.gif&oldid=448129674
https://commons.wikimedia.org/w/index.php?title=File:K-means_convergence.gif&oldid=448129674
https://commons.wikimedia.org/w/index.php?title=File:K-means_convergence.gif&oldid=448129674
https://doi.org/10.1007/s13349-020-00421-4
https://doi.org/10.1007/s13349-020-00421-4
https://doi.org/10.1109/MCSE.2007.55


UCM

[14] M. Jacomy, T. Venturini, S. Heymann y M. Bastian, «ForceAtlas2, a continuous
graph layout algorithm for handy network visualization designed for the Gephi
software,» PloS one, vol. 9, n.o 6, e98679, 2014.

[15] P. Jupyter, iPyWidgets, 2015. dirección: https://github.com/jupyter-widgets/
ipywidgets.

[16] L. Kaufman y P. J. Rousseeuw, Finding groups in data, en, 99.a ed., L. Kaufman
y P. J. Rousseeuw, eds., ép. Probability & Mathematical Statistics S. Nashville,
TN: John Wiley & Sons, abr. de 1990.

[17] ——, Clustering by means of medoids, I. D. Y y editor, eds., Amsterdam: 1987.
[18] T. Kluyver y col., «Jupyter Notebooks – a publishing format for reproducible

computational workflows,» en Positioning and Power in Academic Publishing: Pla-
yers, Agents and Agendas, F. Loizides y B. Schmidt, eds., IOS Press, 2016, págs. 87-90.

[19] V.-T. Luu, G. Forestier, J. Weber, P. Bourgeois, F. Djelil y P.-A. Muller, «A review
of alignment based similarity measures for web usage mining,» Artificial Intelligence
Review, vol. 53, mar. de 2020. doi: 10.1007/s10462-019-09712-9.

[20] J. MacQueen y col., «Some methods for classification and analysis of multivaria-
te observations,» en Proceedings of the fifth Berkeley symposium on mathematical
statistics and probability, Oakland, CA, USA, vol. 1, 1967, págs. 281-297.

[21] V. Mehta, S. Bawa y J. Singh, «Analytical review of clustering techniques and
proximity measures,» Artificial Intelligence Review, vol. 53, n.o 8, págs. 5995-6023,
2020.

[22] H.-S. Park y C.-H. Jun, A simple and fast algorithm for K-medoids clustering, en,
mar. de 2009. doi: 10.1016/j.eswa.2008.01.039. dirección: http://dx.doi.org/
10.1016/j.eswa.2008.01.039.

[23] F. Pedregosa y col., «Scikit-learn: Machine Learning in Python,» Journal of Ma-
chine Learning Research, vol. 12, págs. 2825-2830, 2011.

[24] G. Perrone, J. Unpingco y H.-m. Lu, «Network visualizations with Pyvis and
VisJS,» arXiv preprint arXiv:2006.04951, 2020.

[25] M. Plantié y M. Crampes, «Survey on social community detection,» en Social media
retrieval, Springer, 2013, págs. 65-85.

[26] J. Sander, M. Ester, H.-P. Kriegel y X. Xu, «Density-Based Clustering in Spatial
Databases: The Algorithm GDBSCAN and Its Applications,» Data Mining and
Knowledge Discovery, vol. 2, págs. 169-194, 2004.

[27] M. Shinn, ForceAtlas2 graph layout algorithm for Python, 2016. dirección: https:
//launchpad.net/forceatlas2-python.

[28] N. Simon, The participatory museum. Museum 2.0, 2010.
[29] F. A. Vazquez Saraullo, F. Larosa, R. Ghignone y L. Lanzillotta, «Diseño, imple-

mentación y ensayo de un lector de colores de bajo costo para personas ciegas y
disminuidas visuales,» sep. de 2019.

[30] R. Yurchak et al, scikit-learn-extra, 2020. dirección: https://github.com/scikit-
learn-contrib/scikit-learn-extra.

58

https://github.com/jupyter-widgets/ipywidgets
https://github.com/jupyter-widgets/ipywidgets
https://doi.org/10.1007/s10462-019-09712-9
https://doi.org/10.1016/j.eswa.2008.01.039
http://dx.doi.org/10.1016/j.eswa.2008.01.039
http://dx.doi.org/10.1016/j.eswa.2008.01.039
https://launchpad.net/forceatlas2-python
https://launchpad.net/forceatlas2-python
https://github.com/scikit-learn-contrib/scikit-learn-extra
https://github.com/scikit-learn-contrib/scikit-learn-extra


Pablo Daurell Marina y Alberto García Doménech

2021

Last Update: 30 de mayo de 2022

LATEX lic. LPPL & powered by TEFLO
N CC-ZERO

Esta obra está bajo una licencia Creative Commons «CC0 1.0
Universal».

https://creativecommons.org/publicdomain/zero/1.0/deed.es
https://creativecommons.org/publicdomain/zero/1.0/deed.es
https://creativecommons.org/publicdomain/zero/1.0/deed.es

	Introducción
	Motivación
	Objetivos
	Plan de trabajo

	Estructura de la memoria

	Estado del arte
	Medidas de similitud
	Técnicas de Clustering
	Algoritmos de partición
	Algoritmos jerárquicos
	Algoritmos basados en la densidad

	Visualización de grafos
	Herramientas de visualización de grafos
	Algoritmos de distribución de grafos

	Resumen del capítulo

	Desarrollo de la arquitectura
	Caso de uso: Museo del Prado
	Datos

	Modelado de comunidades
	Similitud entre usuarios
	Similitud entre obras

	Clustering
	Explicación y visualización
	Explicación
	Visualización


	Descripción funcional de la arquitectura
	Interfaz de usuario
	Generación de matrices de similitud
	Interfaz gráfica para calcular las similitudes

	Formación de los clusters
	Interfaz gráfica para generar los clusters

	Generación de las explicaciones
	Interfaz gráfica para generar las explicaciones

	Generación de la visualización
	Interfaz gráfica para la visualización de las comunidades


	Conclusiones y trabajo futuro
	Conclusiones
	Trabajo futuro

	Trabajo Individual
	Alberto García
	Pablo Daurell

	Introduction
	Motivation
	Objectives
	Work plan

	Document structure

	Conclusions and future work
	Conclusions
	Future work