Fuzzy Minimals Clustering

Grado en Ingeniería Informática
Práctica Final
Programación Paralela
Baldomero Imbernón Tudela
Pablo Cano Moreno – 48128407X

Ronald Ernesto Tejada Ríos -B05993056
Curso 2022/2023
Índice de contenidos
1. Abstract .................................................................................................................................. 3
2. Introducción ............................................................................................................................ 4
3. El problema de la clasificación y clusterizado........................................................................ 4
3.1 Clasificación ...................................................................................................................... 5
3.2 Clusterizado ....................................................................................................................... 6
4. Paralelización del algoritmo ................................................................................................... 7
4.1 Código secuencial ............................................................................................................. 7
4.1.1 Descripción del código secuencial ................................................................................ 7
4.1.2 Resultados del código secuencial ............................................................................... 10
4.2 Paralelización en procesadores multinúcleo ................................................................... 11
4.2.2 Comparación de rendimiento con el código secuencial .............................................. 13
4.2.3 Análisis de escalabilidad ............................................................................................. 13
4.3 Paralelización en tarjetas gráficas................................................................................... 15
5. Resultados experimentales .................................................................................................. 19
5.1 Entorno de simulación ..................................................................................................... 19
5.2 Resultados ....................................................................................................................... 21
6. Conclusiones ........................................................................................................................ 23
7. Bibliografía ........................................................................................................................... 24
8. Apéndices............................................................................................................................. 25
Descripción de requisitos del software

1. Abstract
The objective of this work is to use the Fuzzy Minimals classification and clustering algorithm and
modify it so that it can be executed in parallel in order for the code to work faster. It will be done
in both shared memory on the CPU and in GPU with CUDA. When the two ways of doing
parallelization have been done, graphs will be made to check the performance of both and find
out which is better.

2. Introducción
En la actualidad cada vez más personas utilizan Internet, lo cual hace que cada vez se
generen más datos los cuales tienen por nombre “Big Data”. El Big Data es un gran
conjunto de datos de los cuales se puede extraer información. Sin embargo, extraer
información de un conjunto de datos tan grande es bastante complicado aún a día de hoy.
Uno de los métodos para extraer dicha información es mediante los algoritmos de
clustering. La función de estos algoritmos es agrupar un conjunto de elementos dados en
patrones y así poder clasificarlos. (Cebrian, 2020). Grandes compañías como Netflix
utilizan estos algoritmos para conocer los gustos de los consumidores y conocer qué tipo
de series y pelis deben hacer.
Uno de estos algoritmos se llama Fuzzy Minimals. Este es un algoritmo muy potente para
la clusterización. Sin embargo con código lineal va muy lento para un conjunto de datos
muy extenso. Por ello el objetivo de este trabajo es coger ese algoritmo ya establecido y
modificarlo para que se pueda ejecutar en paralelo. Se hará este proceso de dos formas:
● Lenguaje de programación OMP: Se medirá el tiempo de ejecución para tres

ficheros distintos, se realizará un análisis de escalabilidad y un estudio de paralelismo
anidado.
● En GPU usando CUDA: Se implementará el algoritmo en CUDA y se medirán
los tiempos de ejecución para los tres ficheros anteriores.
Una vez que se obtenga el tiempo de los dos, se hará un gráfico para comprobar cuál de
las dos maneras es más rápida y por tanto la mejor para nuestro problema de velocidad.
3. El problema de la clasificación y clusterizado

La clasificación y la clusterización son dos métodos de identificación de patrones que se
usan en el aprendizaje automático. Estas técnicas técnicas tienen cierto parecido, su
mayor diferencia es que en el de clasificación se asignan objetos a unas clases definidas,
sin embargo en la clusterización se agrupan los objetos en grupos en función de sus
similitudes. A estos grupos se les conoce como clusters. A continuación vamos a entrar
más en detalle en cada uno de ellos: (Gorini, 2022).

3.1 Clasificación
Estos problemas envían como respuesta una variable cualitativa de la cual se predice la
clase o categoría de esa observación.
Hay varios métodos para predecir la probabilidad que tiene una observación de pertenecer
a una determinada categoría, estos son algunos ejemplos:
● Regresión logística: Esta técnica utiliza las matemáticas para encontrar

similitudes entre dos datos y con ello poder predecir el valor de uno en función del otro.
Los resultados posibles están establecidos de antemano. (Amazon, s. f.)
● K-NN: Es un algoritmo de aprendizaje supervisado. A partir de unos datos
iniciales ya clasificados es capaz de clasificar datos nuevos. Los datos iniciales suelen
estar formados por un atributo objetivo y varios descriptivos. (Merkel, 2020)
● SVMs: Este algoritmo pone los puntos de una muestra en el espacio, se separan
las clases de la manera más amplia posible gracias a un vector soporte en el hiperplano
de separación. Este algoritmo sabe a qué clase pertenecen los datos en base a la posición
en la que esté el punto en el hiperplano. (Mendoza, 2020)
Algunos ejemplos de casos en los que se puede usar son para clasificar coches según su
gama o para clasificar muestras de ADN en función de la enfermedad que tengan.
Normalmente este tipo de problemas calcula la probabilidad de las clases y juegos las
observaciones se clasifican. Se necesita una función que transforme los datos de entrada
en una probabilidad para que sea de una determinada clase.
Además, esta función debe hacer que los distintos resultados sean cercanos a los valores
reales de la clase. Por ejemplo, si A vale 1 y B vale 0, queremos que si el dato tiene un
valor cercano a 1 pertenezca a A y viceversa para B. Se suele utilizar la función de
verosimilitud utilizando los datos de entrenamiento (Tuplas( X, Y)) y los β son los
parámetros que maximizan l(β).(Gonzalo, 2018)
Ilustración 1

3.2 Clusterizado
La principal característica de estos algoritmos es su gran conjunto de técnicas para
determinar grupos en los datos. Al agrupar los datos se quiere encontrar particiones para
dividir los datos pero que sean homogéneos. Esto quiere decir que queremos que los datos
de un mismo grupo sean parecidos pero que los de otros sean muy distintos.
La definición de parecido varía y depende de los datos que se estén estudiando.
Algunos algoritmos de agrupamiento son:
● K-means: Es el algoritmo de agrupamiento más utilizado ya que es el más
simple. Lo que hace es minimizar la varianza de los datos dentro de un grupo. Suele
funcionar mejor con datos pequeños. (Betancourt, 2021)
● DBSCAN: Se basa en la densidad, es utilizado en conjunto de datos que
contienen ruido o valores poco comunes. Hace uso de dos parámetros para determinar si
un punto de datos está en la misma área que otro. (González, 2021)
Un ejemplo de clusterización sería: tenemos k variables de t observaciones de animales.

Se puede usar este algoritmo para agrupar las t observaciones en grupos de animales. Esto
es un problema no supervisado, se obtiene todo de los grupos de datos. (Gonzalo, 2018)

4. Paralelización del algoritmo
4.1 Código secuencial
4.1.1 Descripción del código secuencial

Para el calculo del factor R se ha hecho el siguiente proceso, donde se calcula los centroides de
las columnas. Para posteriormente analizarlos en el cálculo de R (ilustración 1).
Ilustración 2
En esta función se están calculando los centroides (ilustración 2)
Ilustración 3
Acá se calcula el factor R de manera secuencial haciendo uso de funciones que lo apoyen como
el calculo de la matriz de covarianza y su determinante, para ir calculando una constante que
luego servirá para el cálculo del factor R.

Ilustración 4
La descomposición de Cholesky (ilustración 4) trata de igualar una matriz cuadrada a

una matriz que tenga ceros por encima de la diagonal principal por su matriz traspuesta
que tenga todos los números cero abajo de la diagonal principal.
Es muy similar al método LU, pero es más eficiente para matrices grandes. (Rodó, 2019)

Ilustración 5
El código de abajo muestra el calculo de la matriz de covarianza.
Ilustración 6

4.1.2 Resultados del código secuencial

Los ficheros que se han usado para ejecutar el programa son los siguiente:
Fichero Filas Columnas

iris.txt 150 4
txt1000x100 1000 100
hiper10kR10C.txt 10000 10
10khiperelipsoides,csv 10000 100
hiper80kR10.txt 80000 10
Estos son los resultados que se obtuvieron al ejecutar el programa de manera secuencial
(ilustración 6):
Ilustración 7 - resultados secuencial

4.2 Paralelización en procesadores multinúcleo

Se ha hecho un análisis de escalabilidad en el que se ejecuta el programa varias veces con un
determinado número de hilos cada vez para analizar su velocidad. Este es el resultado:
4.2.1 Implementación
Originalmente se había decidido paralelizar esta función, pero los resultados no fueron los
mejores esperados ya que había momentos en los que los datos se solapaban y el determinante
no siempre era el esperado.
Ilustración 8 determinante – OMP -descomposición de Cholesky
La matriz de covarianza es perfectamente paralelizable en OMP. Aunque se optó no por no

paralelizarla.
Ilustración 9 - OMP - Matriz de covarianza

La mejor opción de paralelización que se encontró fue la de usar la paralelización desde el calculo
de f1, usando una reducción y que cada hilo se encargue de sus propias matrices de covarianza
y determinante.
Ilustración 10 - OMP - Calculo de factor R
Los centroides es un apartado sencillo de paralelizar ya que no se mezclan los índices y es muy
fácil hacer el cálculo de los centroides.
Ilustración 11 - OMP - Centroides

4.2.2 Comparación de rendimiento con el código

secuencial
Como se muestra abajo en la tabla de resultados obtenidos. El código OMP es muchísimo más
rápido que el código secuencial. Excepto en el caso de que haya muy poco datos (ver Ilustración
12, fichero iris.txt) donde el rendimiento en secuencial es más rápido.
Si tomamos el promedio de todos los tiempos de todos los casos ejecutados. El código en
paralelo tiene un rendimiento de aproximadamente 7x más rápido (tomando en cuenta los datos
que se muestran los tiempos tanto en OMP y SEQ).
Average of time Modos

Archivos OMP SEQ
10khiperelipsoides,csv 10000x100 761,220208
hiper10kR10C.txt 10000x10 4,6988345 35,212077
hiper30kR10C.txt 30000x10 40,088376 315,9167
hiper60kR10C.txt 60000x10 168,435083 1270,859756
hiper80kR10.txt 80000x10 286,917847
iris.txt 150x4 0,0155125 0,0009935
txt1000x100 1000x100 3,8958275 30,2335375
Grand Total 127,3881863 214,708709
Ilustración 12 Comparativa de tiempos OMP y SECUENCIAL
4.2.3 Análisis de escalabilidad

Para esto se ha usado un archivo de 30,000 filas y 10 columnas, donde se muestra los resultados.
Y se puede ver como consiguiendo el mismo factorR el rendimiento va aumentando
considerablemente.
modo filename rows columns threadsCPU time factorR

OMP hiper30kR10C.txt 30000 10 12 31,14251 0,161334
OMP hiper30kR10C.txt 30000 10 10 34,000854 0,161334
OMP hiper30kR10C.txt 30000 10 6 52,918269 0,161334
OMP hiper30kR10C.txt 30000 10 8 42,406458 0,161334
OMP hiper30kR10C.txt 30000 10 4 81,465563 0,161334
OMP hiper30kR10C.txt 30000 10 2 161,602582 0,161334
OMP hiper30kR10C.txt 30000 10 1 321,028513 0,161334
Ilustración 13 resultados obtenidos al lanzar el mismo fichero y distintos núcleos
Lo mismo se visualiza en la ilustración 14

hiper30kR10C.txt
350
300
250
200
150
hiper30kR10C.txt
100
50
0
1 2 4 6 8 10 12
Ilustración 14 Análisis de escalabilidad en núcleos del CPU
4.2.4 Estudio de paralelismo anidado

Se considero este análisis originalmente. Sin embargo, se optó por no usar un anidamiento
anidado pues la administración de hilos es costosa y peligrosa en cuanto a la virtualización de
hilos lanzados. En especial al tener muchas personas ejecutando en paralelo.
Es por eso que se opto que cada hilo haga su propia matriz de covarianza y determinante (ver
ilustración 10). Solo hay que tener cuidado que cada hilo debe gestionar su propia memoria para
que no haya accesos entre los punteros.

4.3 Paralelización en tarjetas gráficas
4.3.1 Implementación
El principal cambio acá es que ahora la GPU hará todo el calculo de f1 haciendo el calculo dentro
del kernel el cual se usa como el for que se veía en los casos anteriores (ilustración 10)
Ilustración 15 CUDA - Factor R
Acá se muestra el código del Kernel (ilustración 18 y 19) se calcula se manda a llamar el kernel
desde la función Calculo_f1_MAT_CUDA (ilustración 16 y 17).
Ilustración 16 CUDA - función que invoca el kernel parte 1

Ilustración 17 CUDA - función que invoca el kernel parte 2
Como se muestra en las ilustraciones 18 y 19 se puede ver como se aprovecha la localidad

espacial a través de la técnica de tiling con la memoria compartida de los multiprocesadores.
Esto es para hacer la suma de los f1 de todo un bloque y finalmente cuando el kernel termine
hacer la suma de las sumas (de cada bloque del kernel) y calcular el f1 final que nos sirve para
calcular el buscado factor R.
Ilustración 18 Kernel para calcular F1 parte 1

Cabe recalcar que es muy importante las sincronizaciones de los hilos ya que se está usando
memoria compartida entre bloques y es necesario tener toda la información de todos los
bloques antes de poder continuar.
Ilustración 19 Kernel para calcular F1 parte 2
4.3.2 Comparación de rendimiento con el código

secuencial
Como se puede ver en la ilustración 20, en el mejor de los casos el resultado en la GPU tiene un
rendimiento de 183x superior al rendimiento en secuencial. Obteniendo resultados bastante
asombrosos vs el 7x que se obtenía en paralela con OMP aprovechando los núcleos del
procesador.
Average of time Modos
Archivos GPU SEQ
10khiperelipsoides,csv 10000x100 30,259588
hiper10kR10C.txt 10000x10 0,2340125 35,212077
hiper30kR10C.txt 30000x10 1,68133 315,9167
hiper60kR10C.txt 60000x10 6,94253 1270,859756
hiper80kR10.txt 80000x10 13,841022
iris.txt 150x4 0,012503 0,0009935
txt1000x100 1000x100 2,3593055 30,2335375
Grand Total 5,268055909 214,708709
Ilustración 20 Comparativa de tiempos CUDA y SEQ

4.3.3 Desglose de tiempos de ejecución de CUDA

Acá se muestra a continuación los tiempos obtenido en cargar memoria del host al device, la
ejecución del kernel, memoria del device al host y el tiempo total de ejecución del programa.
Ilustración 21 GPU Run - 10k * 10 datos
Ilustración 22GPU Run - 30k * 10 datos
Como se puede comprobar el tiempo de transferencia es mínimo vs la ganancia abismal en

rendimiento global.

5. Resultados experimentales
5.1 Entorno de simulación

Las características de la CPU con el comando lscpu son:
Ilustración 25 CPU Caracteristicas
Información sobre el uso de RAM/CPU con el comando cat /proc/meminfo:
Ilustración 26 meminfo

Ilustración 27 meminfo
Las características de la gpu con el comando lspci -v -s `lspci | grep VGA | awk '{print
$1}'` son:
VGA compatible controller: ASPEED Technology, Inc. ASPEED Graphics Family (rev
30) (prog-if 00 [VGA controller])

5.2 Resultados
Acá se muestra un resumen de los resultados obtenidos en las distintas pruebas.
Ilustración 28 resutlados pruebas

Ilustración 29 Resultados SEC vs OMP vs GPU
Como se muestra a medida que hay más datos, se nota magistralmente el aumento de
rendimiento que se obtiene en OMP vs SEC y especialmente GPU vs SEC y OMP.
Siendo GPU quien mejor rinde.

6. Conclusiones
Tras concluir las distintas pruebas hechas, podemos concluir que el propósito del trabajo ha sido
un éxito. Al hacer que el código se ejecute paralelamente, este gana una velocidad de ejecución
mucho más alta que en secuencial. Además, comparando los dos métodos de paralelización
OPM y CUDA, se ha llegado a la conclusión de que el mejor método para aumentar la velocidad
del algoritmo Fuzzy Minimals es con CUDA.
Programar en CUDA es un paradigma interesante en el que se obtienen rendimientos muy

buenos. Sin embargo, la programación en CUDA es bastante delicada y hay que tener especial
cuidado con la memoria y los tamaños a usar. Si se práctica más y se dominan las bases, la
programación es CUDA es muy superior a la programación OMP y SECUENCIAL.
La programación OMP es muy fácil de programar ya que hay muy pocas diferencias entre la
forma de programar secuencial. Solo hay que tener ciertos cuidados. Lo cual hace que se puedan
obtener grandes ganancias por cortos esfuerzos de programación. Sin embargo, si el dataset a
utilizar es excesivamente grande, es mucho mejor considerar implementar CUDA.

7. Bibliografía
Amazon. (s. f.). ¿Qué es la regresión logística? - Regresión logística - AWS. Amazon
Web Services, Inc. https://aws.amazon.com/es/what-is/logistic-regression/
Betancourt, J. C. M. (2021, 16 diciembre). 8 algoritmos de agrupación en clústeres en el
aprendizaje automático que todos los científicos de datos deben conocer.
freeCodeCamp.org.
Cebrian, J. M., Imbernón, B., Soto, J., García, J. M., & Cecilia, J. M. (2020). High-
throughput fuzzy clustering on heterogeneous architectures. Future Generation
Computer Systems, 106, 401-411.
González, L. (2021, 8 septiembre). DBSCAN Teoría. Aprende IA.
https://aprendeia.com/dbscan-teoria/
Gonzalo, A. (2018, 25 diciembre). Problemas comunes en aprendizaje automático.
MachineLearningParaTodos.com. Recuperado 10 de enero de 2023, de
https://machinelearningparatodos.com/problemas-comunes-en-aprendizaje-automatico/
Gorini, M. (2022, 5 abril). Clasificación vs. clusterización: una explicación práctica.
https://blog.bismart.com/la-clasificaci%C3%B3n-y-la-clusterizaci%C3%B3n-una-
explicaci%C3%B3n-pr%C3%A1ctica https://www.freecodecamp.org/espanol/news/8-
algoritmos-de-agrupacion-en-clusteres-en-el-aprendizaje-automatico-que-todos-los-
cientificos-de-datos-deben-conocer/
Mendoza, J. (2020, 23 noviembre). ¿Qué es un modelo SVM?
https://estadisticamente.com/que-es-un-modelo-svm/
Merkle. (2020, 1 septiembre). El algoritmo K-NN y su importancia en el modelado de
datos | Blog. Recuperado 15 de enero de 2023, de
https://www.merkle.com/es/es/blog/algoritmo-knn-modelado-datos
Rodó, P. (2019, 13 mayo). Descomposición de Cholesky. Economipedia.

https://economipedia.com/definiciones/descomposicion-de-cholesky.html

8. Apéndices
Ilustración 1 ................................................................................................................................... 5
Ilustración 2 ................................................................................................................................... 7
Ilustración 3 ................................................................................................................................... 7
Ilustración 4 ................................................................................................................................... 8
Ilustración 5 ................................................................................................................................... 9
Ilustración 6 ................................................................................................................................... 9
Ilustración 7 - resultados secuencial ........................................................................................... 10
Ilustración 8 determinante – OMP -descomposición de Cholesky .............................................. 11
Ilustración 9 - OMP - Matriz de covarianza ................................................................................. 11
Ilustración 10 - OMP - Calculo de factor R .................................................................................. 12
Ilustración 11 - OMP - Centroides ............................................................................................... 12
Ilustración 12 Comparativa de tiempos OMP y SECUENCIAL .................................................. 13
Ilustración 13 resultados obtenidos al lanzar el mismo fichero y distintos núcleos .................... 13
Ilustración 14 Análisis de escalabilidad en núcleos del CPU ...................................................... 14
Ilustración 15 CUDA - Factor R ................................................................................................... 15
Ilustración 16 CUDA - función que invoca el kernel parte 1 ...................................................... 15
Ilustración 17 CUDA - función que invoca el kernel parte 2 ....................................................... 16
Ilustración 18 Kernel para calcular F1 parte 1 ............................................................................ 16
Ilustración 19 Kernel para calcular F1 parte 2 ............................................................................ 17
Ilustración 20 Comparativa de tiempos CUDA y SEQ ................................................................ 17
Ilustración 21 GPU Run - 10k * 10 datos .................................................................................... 18
Ilustración 22GPU Run - 30k * 10 datos ..................................................................................... 18
Ilustración 25 CPU Caracteristicas .............................................................................................. 19
Ilustración 26 meminfo ................................................................................................................ 19
Ilustración 27 meminfo ................................................................................................................ 20
Ilustración 28 resutlados pruebas ............................................................................................... 21
Ilustración 29 Resultados SEC vs OMP vs GPU ........................................................................ 22

Fuzzy Minimals Clustering

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fuzzy Minimals Clustering

Cargado por

Copyright:

Formatos disponibles

Grado en Ingeniería Informática

Baldomero Imbernón Tudela

Pablo Cano Moreno – 48128407X

Descripción de requisitos del software

Descripción de requisitos del software

● Lenguaje de programación OMP: Se medirá el tiempo de ejecución para tres

3. El problema de la clasificación y clusterizado

Descripción de requisitos del software

● Regresión logística: Esta técnica utiliza las matemáticas para encontrar

Descripción de requisitos del software

Un ejemplo de clusterización sería: tenemos k variables de t observaciones de animales.

Descripción de requisitos del software

4. Paralelización del algoritmo

4.1 Código secuencial

4.1.1 Descripción del código secuencial

En esta función se están calculando los centroides (ilustración 2)

Descripción de requisitos del software

La descomposición de Cholesky (ilustración 4) trata de igualar una matriz cuadrada a

Descripción de requisitos del software

El código de abajo muestra el calculo de la matriz de covarianza.

Descripción de requisitos del software

4.1.2 Resultados del código secuencial

Fichero Filas Columnas

Ilustración 7 - resultados secuencial

Descripción de requisitos del software

4.2 Paralelización en procesadores multinúcleo

Ilustración 8 determinante – OMP -descomposición de Cholesky

La matriz de covarianza es perfectamente paralelizable en OMP. Aunque se optó no por no

Ilustración 9 - OMP - Matriz de covarianza

Descripción de requisitos del software

Ilustración 10 - OMP - Calculo de factor R

Ilustración 11 - OMP - Centroides

Descripción de requisitos del software

4.2.2 Comparación de rendimiento con el código

Average of time Modos

Ilustración 12 Comparativa de tiempos OMP y SECUENCIAL

4.2.3 Análisis de escalabilidad

modo filename rows columns threadsCPU time factorR

Lo mismo se visualiza en la ilustración 14

Descripción de requisitos del software

Ilustración 14 Análisis de escalabilidad en núcleos del CPU

4.2.4 Estudio de paralelismo anidado

Descripción de requisitos del software

4.3 Paralelización en tarjetas gráficas

Ilustración 15 CUDA - Factor R

Ilustración 16 CUDA - función que invoca el kernel parte 1

Descripción de requisitos del software

Ilustración 17 CUDA - función que invoca el kernel parte 2

Como se muestra en las ilustraciones 18 y 19 se puede ver como se aprovecha la localidad

Ilustración 18 Kernel para calcular F1 parte 1

Descripción de requisitos del software

Ilustración 19 Kernel para calcular F1 parte 2

4.3.2 Comparación de rendimiento con el código

Descripción de requisitos del software

4.3.3 Desglose de tiempos de ejecución de CUDA

Ilustración 21 GPU Run - 10k * 10 datos

Ilustración 22GPU Run - 30k * 10 datos

Ilustración 23 GPU Run - 60k * 10 datos

Ilustración 24 GPU Run - 80k * 10 datos

Como se puede comprobar el tiempo de transferencia es mínimo vs la ganancia abismal en

Descripción de requisitos del software

5.1 Entorno de simulación

Ilustración 25 CPU Caracteristicas

Información sobre el uso de RAM/CPU con el comando cat /proc/meminfo: