DATA MINING, MACHINE LEARNING Y DEEP LEARNING

APRENDIZAJE NO SUPERVISADO
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

© Structuralia 2
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

ÍNDICE

ÍNDICE ........................................................................................................................................................................ 3

1. INTRODUCCIÓN A CLUSTERING: PROPÓSITO Y MÉTRICAS ............................................................................ 4

1.1 ¿Qué es el aprendizaje no supervisado? .............................................................................................................. 4

1.2 Clustering .............................................................................................................................................................. 4
1.3 Métricas ................................................................................................................................................................. 5

2. K-MEANS CLUSTERING ........................................................................................................................................ 18

2.1 Algoritmo K-Means .............................................................................................................................................. 18

2.2 Técnicas de selección del número de clústers .................................................................................................... 21

3. CLÚSTERING JERÁRQUICO, OTRAS TÉCNICAS Y EJEMPLOS ....................................................................... 25

3.3 Clustering Jerárquico ........................................................................................................................................... 25

3.4 Otros algoritmos .................................................................................................................................................. 30
3.5 Ejemplos .............................................................................................................................................................. 31

4. ANÁLISIS DE COMPONENTES PRINCIPALES (PCA) ......................................................................................... 49

4.6 Introducción ......................................................................................................................................................... 49

4.7 Definición algebráica ........................................................................................................................................... 56
4.8 Otros algoritmos de extracción de rasgos ........................................................................................................... 59

5. EJERCICIO DE EJEMPLO PCA ............................................................................................................................. 60

6. REFERENCIAS ....................................................................................................................................................... 71

3 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

1. INTRODUCCIÓN A CLUSTERING: PROPÓSITO Y MÉTRICAS

1.1 ¿Qué es el aprendizaje no supervisado?

Como ya se mencionó en la introducción, el aprendizaje no supervisado se caracteriza por incluir

dentro de él un tipo de algoritmos que no necesitan tener datos con unas categorías predefinidas
para poder extraer información de dicho conjunto de datos. De esta forma su rango de aplicación
a diversos problemas es mucho mayor en potencia que el del aprendizaje supervisado pues
simplemente requiere de un conjunto de datos inicial para poder extraer relaciones entre los
mismos.

Esto se puede aplicar a distintos tipos de problemas, como la detección de valores atípicos, la
identificación de componentes principales dentro de los datos y reducción de dimensionalidad, o
la segmentación de datos dentro de grupos de datos similares con técnicas de clústering.

Las técnicas de clústering son el ejemplo más sencillo, y a la vez más usado, de técnicas de
aprendizaje no supervisado. Por este motivo se verán en más profundidad al tiempo que se
introducirán algunas otras técnicas populares.

1.2 Clustering

Por cluster se entiende una colección concreta de objetos o datos que guardan entre sí una cierta
similaridad y que son diferentes en algún aspecto a los objetos de otros clusteres.

Así pues, con los algoritmos de clustering se pretende encontrar de forma automática y no
supervisada estos grupos de datos dentro de los conjuntos de datos de entrenamiento.

Las aplicaciones de estos algoritmos son varias:

▪ Marketing: Permite descubrir grupos de clientes similares de manera que se puedan

preparar estrategias específicas para uno de estos grupos de clientes.

▪ Visión Artificial: Se pueden analizar imágenes para encontrar grupos de las mismas que
sean similares.

© Structuralia 4
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

▪ Minería de Textos: Otra aplicación consiste en encontrar documentos de características

similares de manera que se obtengan así distintos grupos de textos parecidos. De esta
manera, si se consulta un documento concreto un sistema podría recomendar otros
documentos similares del clúster al que pertenece el documento consultado.

Esto grupos se podrían etiquetar a posteriori con, por ejemplo, con las palabras más
habituales dentro de los mismos, de manera que ante una consulta en un buscador
podrán aparecer los documentos del clúster cuya etiqueta de palabras coincida más con
las palabras usadas en la consulta.

▪ Retail: Los distintos productos se podrían agrupar dentro de un conjunto de datos de

productos similares para recomendar un catálogo concreto de posibilidades a un cliente
interesado en uno de ellos.

Ilustración 1 Ejemplo de clustering; se encuentran dos grupos para un conjunto de datos sin ninguna categoría
asociada; solo se dispone de sus variables de entrada X1 y X2.

1.3 Métricas

Como se ha mencionado previamente, un buen algoritmo de clustering encontrará grupos de

datos muy parecidos entre sí (cohesión) y muy diferentes del resto de clústers (aislamiento).

5 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 2 Dos ejemplos de agrupaciones. En el primer caso se tiene poca cohesión y poco aislamiento sobre todo
por el cluster de en medio; en él los datos son bastante diferentes y muy cercanos a los otros dos clusters. Sin
embargo, para los mismos datos, el segundo ejemplo propone una agrupación de mayor cohesión y mejor
aislamiento.

Todos los algoritmos de clustering compartirán lo siguiente:

▪ Entrada:

o Los n datos sobre los que hacer clustering y que proporcionan dos matrices de
datos:

Matriz de rasgos: Esta matriz contiene los datos disponibles y las variables de
entrada asociadas a cada registro.

𝑀𝑅𝑛 𝑥 𝑝 𝑐𝑜𝑛 𝒏 𝑒𝑙 𝑛º 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠 𝑦 𝒑 𝑒𝑙 𝑛º 𝑑𝑒 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎

Así, MR(i,j) correspondería al valor de la variable de entrada j en el dato i.

Matriz de distancias o diferencias: Esta matriz recoge las diferencias que

existen entre cada par de datos del conjunto de entrenamiento, diferencia que se
puede medir en términos de distancias.

𝑀𝐷𝑛 𝑥 𝑛 𝑐𝑜𝑛 𝒏 𝑒𝑙 𝑛º 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠

Así, MD(i,j) corresponde a la diferencia existente entre el dato i y el dato j.

Se puede obtener en función de los valores que tienen la matriz de rasos MR.

© Structuralia 6
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Al ser una matriz de diferencias se cumple que:

• MD(i,j) = MD(j,i)

• MD(i,i) = 0

o Opcionalmente el número de clústers que se quieren crear (k)

▪ Salida:

o Los datos agrupados en los k clusters

Uso de distancias para obtener las diferencias1

Algunos de los modelos de clustering usan la distancia entre puntos como medida de la
diferencia/similitud de los mismos.

De esta manera se tendría como matriz de diferencias:

0 𝑑(1,2) … 𝑑(1, 𝑛 − 1) 𝑑(1, 𝑛)

𝑑(2,1) 0 … 𝑑(2, 𝑛 − 1) 𝑑(2, 𝑛)
𝑀𝐷 = ⋮ ⋮ ⋱ ⋮ ⋮
𝑑(𝑛 − 1, 1) 𝑑(𝑛 − 1,2) … 0 𝑑(𝑛 − 1, 𝑛)
[ 𝑑(𝑛, 1) 𝑑(𝑛, 2) … 𝑑(𝑛, 𝑛 − 1) 0 ]

Con d la distancia entre puntos.

La distancia entre puntos se debe calcular atendiendo siempre al tipo de variables de entrada
utilizadas; es decir, dependiendo de si estas son numéricas, nominales, ordinales o mixtas.

1 Fuente: Apuntes del Máster de Ingeniería de Sistemas de Decisión de la URJC, Minería de Datos

7 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Distancia general:

De manera general se recuerda las expresiones de las distancias Euclidea y Manhattan:

𝑝
𝑞
𝑞
𝑑(𝑖, 𝑗) = √(∑|𝑥𝑖𝑝 − 𝑥𝑗𝑝 | )
1

𝑆𝑖 𝑞 = 1 → 𝑀𝑎𝑛ℎ𝑎𝑡𝑡𝑎𝑛

𝑆𝑖 𝑞 = 2 → 𝐸𝑢𝑐𝑙𝑖𝑑𝑒𝑎

De esta forma se calcularía la distancia para un par de puntos i,j en función de las distancias
entre sus variables de entrada.

Al ser una distancia cumple las propiedades generales de las mismas:

▪ 𝑑(𝑖, 𝑗) ≥ 0

▪ 𝑑(𝑖, 𝑖) = 0

▪ 𝑑(𝑖, 𝑗) = 𝑑(𝑗, 𝑖)

▪ 𝑑(𝑖, 𝑗) ≤ 𝑑(𝑖, 𝑘) + 𝑑(𝑘, 𝑗)

Variables Binarias:

Las distancias para variables binarias se suelen calcular con lo que se conoce como tablas de
contingencia.

1 0 suma

1 a b a+b

0 c d c+d

suma a+c b+d p

© Structuralia 8
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

De esta manera, la distancia entre variable podría medirse con alguna de las fórmulas siguientes:

𝑏+𝑐
𝑫𝒊𝒔𝒕𝒂𝒏𝒄𝒊𝒂 𝒔𝒊𝒎𝒑𝒍𝒆 → 𝑑(𝑖, 𝑗) =
𝑎+𝑏+𝑐+𝑑
𝑏+𝑐
𝑫𝒊𝒔𝒕𝒂𝒏𝒄𝒊𝒂 𝒔𝒊𝒎𝒑𝒍𝒆 (𝑜𝑡𝑟𝑜 𝑒𝑗𝑒𝑚𝑝𝑙𝑜) → 𝑑(𝑖, 𝑗) =
𝑎+𝑏+𝑐
𝑎
𝑪𝒐𝒆𝒇𝒊𝒄𝒊𝒆𝒏𝒕𝒆 𝒅𝒆 𝑱𝒂𝒄𝒄𝒂𝒓𝒅 → 𝑑(𝑖, 𝑗) =
𝑎+𝑏+𝑐

𝑫𝒊𝒔𝒕𝒂𝒏𝒄𝒊𝒂 𝑯𝒂𝒎𝒎𝒊𝒏𝒈 → 𝑑(𝑖, 𝑗) = 𝑏 + 𝑐

Ejemplo:

Animal Vertebrado Reptil Mamífero Ave Felino Insecto

Perro 1 0 1 0 0 0

Gato 1 0 1 0 1 0

Cocodrilo 1 1 0 0 0 0

De la tabla de datos anterior se pasa, para cada par de datos, a la tabla de contingencias donde
para cada término a,b,c y d se van sumando valores según sean los valores de los pares de cada
variable de entrada.

▪ 𝑎 → 𝑠𝑒 𝑠𝑢𝑚𝑎 1 𝑝𝑜𝑟 𝑐𝑎𝑑𝑎 𝑝𝑎𝑟 𝑑𝑒 𝑣𝑎𝑙𝑜𝑟𝑒𝑠 (1,1)

▪ 𝑏 → 𝑠𝑒 𝑠𝑢𝑚𝑎 1 𝑝𝑜𝑟 𝑐𝑎𝑑𝑎 𝑝𝑎𝑟 𝑑𝑒 𝑣𝑎𝑙𝑜𝑟𝑒𝑠 (1,0)

▪ 𝑐 → 𝑠𝑒 𝑠𝑢𝑚𝑎 1 𝑝𝑜𝑟 𝑐𝑎𝑑𝑎 𝑝𝑎𝑟 𝑑𝑒 𝑣𝑎𝑙𝑜𝑟𝑒𝑠 (0,1)

▪ 𝑑 → 𝑠𝑒 𝑠𝑢𝑚𝑎 1 𝑝𝑜𝑟 𝑐𝑎𝑑𝑎 𝑝𝑎𝑟 𝑑𝑒 𝑣𝑎𝑙𝑜𝑟𝑒𝑠 (0,0)

(𝑃𝑒𝑟𝑟𝑜, 𝐺𝑎𝑡𝑜) = (𝑎 = 1 + 1 = 2 𝑏=0

)= (
2 0
)
𝑐=1 𝑑 =1+1+1=3 1 3

(𝑃𝑒𝑟𝑟𝑜, 𝐶𝑜𝑐𝑜𝑑𝑟𝑖𝑙𝑜) = (𝑎 = 1 𝑏=1

)= (
1 1
)
𝑐 =1 𝑑 =1+1+1=3 1 3

9 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

(𝐺𝑎𝑡𝑜, 𝐶𝑜𝑐𝑜𝑑𝑟𝑖𝑙𝑜) = (𝑎 = 1 𝑏 =1+1=2

)= (
1 2
)
𝑐=1 𝑑 =1+1=2 1 2

Usando la primera medida de distancias expuesta, los resultados serían:

𝑏+𝑐 0+1
𝑑(𝑃𝑒𝑟𝑟𝑜, 𝐺𝑎𝑡𝑜) = = = 0.2
𝑎+𝑏+𝑐+𝑑 2+0+1+2
𝑏+𝑐 1+1
𝑑(𝑃𝑒𝑟𝑟𝑜, 𝐶𝑜𝑐𝑜𝑑𝑟𝑖𝑙𝑜) = = = 0.33
𝑎+𝑏+𝑐+𝑑 1+1+1+3
𝑏+𝑐 2+1
𝑑(𝐺𝑎𝑡𝑜, 𝐶𝑜𝑐𝑜𝑑𝑟𝑖𝑙𝑜) = = = 0.5
𝑎+𝑏+𝑐+𝑑 1+2+1+2

Variables Nominales:

Estas variables se pueden ver como una generalización de las variables binarias, extrapolando
para el caso de más de dos categorías.

De esta forma, un método para trabajar con ellas consistiría en construir una variable binaria
nueva para cada uno de los M estados nominales y con todas esas variables binarias se
calcularían las distancias como en el caso anterior.

Ejemplo:

𝑐𝑜𝑙𝑜𝑟 𝑑𝑒 𝑝𝑒𝑙𝑜 = {𝑚𝑎𝑟𝑟ó𝑛, 𝑔𝑟𝑖𝑠, 𝑛𝑒𝑔𝑟𝑜} = {1, 2, 3}

Color de Pelo X1 X2

Marrón 0 0

Gris 1 0

Negro 0 1

De esta forma se pasa de una variable multiclase de dimensión M a M -1 variables binarias

creadas a posteriori sobre las que ya se podría aplicar la medida de distancias vista antes.

© Structuralia 10
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Otro método más sencillo consiste en usar la fórmula de Simple Matching:

𝑝−𝑚
𝑑(𝑖, 𝑗) =
𝑝

𝑐𝑜𝑛 𝒎: 𝑒𝑙 𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑜𝑖𝑛𝑐𝑖𝑑𝑒𝑛𝑐𝑖𝑎𝑠 𝑦 𝒑: 𝑒𝑙 𝑛ú𝑚𝑒𝑟𝑜 𝑡𝑜𝑡𝑎𝑙 𝑑𝑒 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠

Variables Ordinales:

Las variables ordinales pueden ser tanto discretas como continuas y se caracterizan por ser
variables en las que el orden es significativo.

Ejemplo:

▪ Rango de precio de viviendas: variable numérica ordinal, ya que el precio tiene un orden

▪ Categorías profesionales: Becario, Ingeniero Junior, Ingeniero Senior, Team Leader…

Son variables categóricas pero ordinales, ya que responden a una jerarquización.

En estos casos se trabaja directamente con el vector de variables (convirtiéndolo a un vector

numérico en el caso de que sean categóricas).

𝐶𝑎𝑡𝑒𝑔𝑜𝑟í𝑎𝑠 𝑝𝑟𝑜𝑓𝑒𝑠𝑖𝑜𝑛𝑎𝑙𝑒𝑠 =
{𝐵𝑒𝑐𝑎𝑟𝑖𝑜, 𝐼𝑛𝑔𝑒𝑛𝑖𝑒𝑟𝑜 𝐽𝑢𝑛𝑖𝑜𝑟, 𝐼𝑛𝑔𝑒𝑛𝑖𝑒𝑟𝑜 𝑆𝑟. , 𝑇𝑒𝑎𝑚 𝐿𝑒𝑎𝑑𝑒𝑟, 𝐷𝑇𝑂, 𝐶𝑂𝑂, 𝐶𝐸𝑂} → {0,1,2,3,4,5,6}

Otras medidas de distancia:

Además de las medidas expresadas, como medidas de distancias se pueden usar las dos
siguientes:

Medida de coseno

⃗⃗⃗⃗
𝑋𝑡 𝑌 ⃗
𝑠(𝑋⃗, 𝑌
⃗⃗) =
|𝑋||𝑌 ⃗|

11 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Coeficiente de Tanimoto

⃗⃗⃗⃗
𝑋𝑡 𝑌 ⃗
𝑠(𝑋⃗, 𝑌
⃗⃗) =
⃗⃗⃗⃗
𝑋𝑡 𝑋 + 𝑌⃗⃗⃗⃗𝑡 𝑌 ⃗⃗⃗⃗𝑡 𝑌
⃗ − 𝑋 ⃗

Normalización y Estandarización de Datos:

Recordando del capítulo anterior, cuando se trabaja con distancias es recomendable siempre
hacer un feature scaling de las variables empleadas.

Existen varias formas de hacerlo, siendo dos métodos populares la normalización o la

estandarización de datos.

Normalización

La normalización de datos se puede hacer de la siguiente forma:

𝑥𝑖 − min (𝑥)
𝑧𝑖 =
max(𝑥) − min (𝑥)

𝑐𝑜𝑛 𝑥 = (𝑥1 , 𝑥2 , … , 𝑥𝑛 )𝑦 𝑧𝑖 𝑒𝑙 𝑑𝑎𝑡𝑜 𝑛𝑜𝑟𝑚𝑎𝑙𝑖𝑧𝑎𝑑𝑜

La normalización permite obtener los valores originales en una escala de (0,1), de manera que
las magnitudes pasen a ser comparables entre sí.

Estandarización

La fórmula para estandarizar datos es:

𝑥𝑖 − 𝜇
𝑧𝑖 =
𝜎

𝑐𝑜𝑛 𝜇 𝑙𝑎 𝑚𝑒𝑑𝑖𝑎 𝑑𝑒 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠 𝑦 𝜎 𝑙𝑎 𝑑𝑒𝑠𝑣𝑖𝑎𝑐𝑖ó𝑛 𝑡í𝑝𝑖𝑐𝑎

© Structuralia 12
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

La estandarización en lugar de reescalar los datos a un intervalo (0,1) lo hace para un intervalo
arbitrario que cumple que la media 𝜇 es 0 y la desviación 𝜎 es 1. La ventaja que tiene la
estandarización frente a la normalización es que además de reescalar los datos no pierde
características importantes de los mismos especialmente en lo referente a los valores atípicos;
la normalización hace que los puntos con valores atípicos dejen de ser como tal atípicos, con lo
que se pierde una parte importante de información. Por este motivo se recomienda el uso, como
normal general, de la estandarización.

De igual forma, la ventaja que tendría la normalización es que todos los datos pasarían a estar
dentro de un intervalo fijo de valores, a diferencia de la estandarización que define un rango de
valores no fijo y que dependerá sólo de que se cumpla ese valor medio y de desviación. La
ventaja/desventaja (según el caso) que además tiene la estandarización es que tras el
reescalado de valores habrá potencialmente valores negativos, algo que no ocurre en la
normalización.

Medidas de heterogeneidad del clúster

Como se ha ido adelantando, la calidad de partición del espacio con los algoritmos de clústering
se puede medir comprobando la heterogeneidad o falta de cohesión del clúster H(Cr).

Esta heterogeneidad se puede expresar de la siguiente forma:

𝑘 𝑝 𝑘 𝑝

H(cr ) = ∑ ∑(𝑥𝑘𝑗 − 𝐶𝑘 )2 = ∑ ∑(𝑥𝑘𝑗 − ̅̅̅)

𝑥𝑘 2
𝑚=1 𝑗=1 𝑚=1 𝑗=1

𝑐𝑜𝑛 𝒌 𝑒𝑙 𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑐𝑙ú𝑠𝑡𝑒𝑟𝑠, 𝒑 𝑒𝑙 𝑛ú𝑚𝑒𝑟𝑜 𝑑𝑒 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠 𝑑𝑒 𝑒𝑛𝑡𝑟𝑎𝑑𝑎 𝑝𝑟𝑒𝑠𝑒𝑛𝑡𝑒𝑠 𝑒𝑛 𝑙𝑜𝑠 𝑑𝑎𝑡𝑜𝑠

𝑦 𝐶𝑘 𝑒𝑙 𝑐𝑒𝑛𝑡𝑟𝑜𝑖𝑑𝑒 𝑑𝑒𝑙 𝑐𝑙ú𝑠𝑡𝑒𝑟

13 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

De esta forma, el criterio de particiones es en general que dado un número de clústers k, un

conjunto de datos de tamaño n, se busca minimizar la siguiente expresión, conocida como WCSS
(within cluster sum square):

𝑘 𝑝

𝑥𝑘 2 )
min ( ∑ ∑(𝑥𝑘𝑗 − ̅̅̅)
𝑚=1 𝑗=1

El criterio sería así minimizar la distancia de los puntos de un clúster a su centroide.

La expresión anterior también se puede expresar en función de la distancia euclídea:

∑𝑖,𝑗 ∈𝐶𝑟 𝑑𝑖,𝑗

𝐻(𝑐𝑟 ) =
2𝑛𝑟

𝐶𝑜𝑛 𝑑𝑖,𝑗 𝑒𝑙 𝑐𝑢𝑎𝑑𝑟𝑎𝑑𝑜 𝑑𝑒 𝑙𝑎 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 𝑒𝑢𝑐𝑙í𝑑𝑒𝑎

De esta forma, para este segundo caso habría que minimizar la siguiente función:

𝑚𝑖𝑛 ( ∑ 𝑑𝑖,𝑗 )
𝑖,𝑗 ∈𝐶𝑟

Ward: A diferencia de la métrica anterior donde se busca minimizar la WCSS, el método de Ward
funcionaría de forma análoga pero buscando minimizar la varianza dentro del clúster.

© Structuralia 14
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Medidas de separación del clúster

Por otro lado, existe la medida de separación del clúster I(Cr), que mide la calidad del clúster en
función de la separación de éste respecto al resto de clústers. Algunas métricas para medir la
separación de clústers son:

Single-Link: Métrica que recoge la menor distancia que existe entre el elemento de un clúster y
el de otro clúster.

𝑑(𝐾𝑖, 𝐾𝑗) = min(𝑥𝑖𝑝 , 𝑥𝑗𝑞 )

Max-Link: Métrica que recoge la mayor distancia que existe entre el elemento de un clúster y el
de otro clúster.

𝑑(𝐾𝑖, 𝐾𝑗) = max(𝑥𝑖𝑝 , 𝑥𝑗𝑞 )

Average-Link: Métrica que recoge el promedio de las distancias entre el elemento de un clúster
y el de otro clúster.

𝑑(𝐾𝑖, 𝐾𝑗) = media(𝑥𝑖𝑝 , 𝑥𝑗𝑞 )

15 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 3 Imagenes donde se ven visualmente las métricas expuestas antes; en el caso del average-link sería la
media de todas las distancias, mostrada en la imagen para un dato como ejemplo.

Centroid: Distancia entre los centroides de dos clusters, siendo este la media aritmética de todos
los puntos del cluster (y pudiendo por ello ser un punto ficticio no existente en el cluster).

𝑑(𝐾𝑖, 𝐾𝑗) = dis(𝐶𝑖 , 𝐶𝑗 )

Medoid: Distancia entre los medoides de los clusters, siendo el medoide el objeto central del
clúster. A diferencia del centroide el medoide ha de ser uno de los puntos existentes del cluster.

𝑑(𝐾𝑖, 𝐾𝑗) = dis(𝑀𝑖 , 𝑀𝑗 )

© Structuralia 16
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

I(Cr) representaría alguna de esas distancias indicadas, de forma que el segundo objetivo sería
maximizar dicha medida I(Cr) ya que el mejor resultado es el que tiene los clústers más diferentes,
es decir, más separados entre sí. Para un caso de de p clústers sería:

max (∑ 𝐼(𝐶𝑝 ))
𝑗=1

Cogiendo como ejemplo la métrica de single-link I(Cr) sería:

𝐼(𝐶𝑟 ) = 𝑚𝑖𝑛{𝑖 ∈𝐶𝑅 ,𝑗 ∉𝐶𝑟 } 𝑑𝑖𝑗

17 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

2. K-MEANS CLUSTERING

2.1 Algoritmo K-Means

El algoritmo de K-Means es un ejemplo de esos algoritmos de partición en el que se definen los

clústers de forma que se intenten optimizar las métricas antes expuestas. Este algoritmo es un
algoritmo iterativo en el que se van asignando los puntos al clúster que mejores métricas da.

1. Elegir el número de clústers

2. Elegir K puntos aleatorios como centroides (si son centroides pueden ser puntos que no
existan en los datos, si son medoides han de ser puntos reales)

3. Asignar cada punto del conjunto de datos al centroide más cercano según alguna de las
medidas de distancia comentadas, teniéndose así k clústers

4. Calcular y colocar el nuevo centroide en función de los puntos que haya dentro de cada
clúster.

5. Si ha cambiado el centroide:

▪ Usando ese nuevo centroide, volver al paso 3

6. Sino:

▪ Terminar

© Structuralia 18
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 4 Esquema de funcionamiento del algoritmo de K-Means

Ventajas:

▪ Es un algoritmo bastante eficiente; su ejecución es O(tkn) con n el número de

datos, k el número de clústers y t las iteraciones usadas.

Desventajas:

▪ Se puede caer en mínimos locales que hagan que el problema se detenga en una
solución que no es la más eficiente (y esto está muy influido por la posición inicial
de los centroides).

▪ Se necesita conocer el valor de k desde el principio.

▪ Alta influencia de valores atípicos ya que el cálculo se hace en función de

distancias.

▪ Se podría llegar a tener un clúster sin puntos (vacío) ya que alguno de los
centroides pueden acabar sin puntos asignados a él.

19 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

K-Means ++

Elegir de forma aleatoria los puntos iniciales puede llevar a agrupaciones de datos finales
totalmente distintas debido a que el espacio de soluciones posibles no es único. Esto se relaciona
con uno de los puntos antes expuestos: este algoritmo es susceptible de caer en un mínimo local
que no sea la mejor solución posible. Por este motivo se han propuesto modificaciones sobre
este algoritmo de clústering que tiene en cuenta la posición inicial de los centroides.

Ilustración 5 Random initialization trap; según dónde se definan los puntos de inicio se pueden obtener agrupaciones
totalmente distintas

Por lo tanto, el algoritmo K-Means ++ es en esencia un algoritmo K-Means pero al que se le

añade un segundo algoritmo encargado de encontrar las mejores posiciones iniciales para los
centroides (que, en este caso, como se elegirán del conjunto de puntos disponibles, propiamente
serán medoides).

Para ello, en primer lugar se sitúa uno de los centroides de los clusters de forma aleatoria. Tras
ello, el resto de centroides se eligen en función de dónde se haya situado dicho clúster inicial.
Esto se realiza de la siguiente forma2:

1. Se elige un primer centroide de forma aleatoria usando una distribución uniforme (es
decir, sin priorizar una posición inicial frente a otras; todas tendrían las mismas
probabilidades) de entre los distintos puntos del conjunto de entrenamiento.

2 Fuente: https://en.wikipedia.org/wiki/K-means%2B%2B

© Structuralia 20
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

2. Para cada punto x del conjunto de datos se calcula la distancia D(x) entre los puntos x y
el/los medoide definido/s

3. Se elige un nuevo punto aleatorio para el siguiente medoide pero en vez de usar una
distribución uniforme se usa una distribución ponderada donde la probabilidad de elegir
un punto en concreto del conjunto de entrenamiento es proporcional a D(x)2

4. Se repiten los puntos 2 y 3 hasta que se tienen posicionados todos los medoides

5. Una vez situados los medoides iniciales se procede con el algoritmo de k-means (es decir,
que los centroides iniciales se eligen como medoides, de entre los datos disponibles, pero
luego el algoritmo itera usando el k-means y ya definiendo centroides de forma
subsiguiente).

K-Medoids

En este caso el algoritmo usaría medoides en lugar de centroides, comenzando con un conjunto
inicial de medoides que se irían reemplazando de forma iterativa por el algoritmo, utilizando de
nuevo las distancias para agrupar a los puntos más cercanos, funcionando por lo tanto de forma
análoga al algoritmo anterior.

2.2 Técnicas de selección del número de clústers

Para los algoritmos descritos previamente se necesita definir de alguna forma el número óptimo
de clústers K para cada conjunto de datos. Para ello se han definido y desarrollado distintas
métricas, algoritmos y procesos que sirvan para este propósito.

Método del codo (Elbow method)

Las métricas para medir la calidad de los resultados de un algoritmo de clústering hacían
referencia a dos categorías: las métricas que miden la calidad de puntos dentro de un propio
clúster, y que buscan que las diferencias entre esos puntos sean lo menor posibles, y las métricas
que miden la diferencia entre distintos clústers, y que buscan que estas sean lo mayor posible.

Así, como la medida de calidad interna del clúster se hace con respecto a la posición del
centroide, interesa que se éste lo más cerca posible de este y que por ello la distancia con
respecto a él sea mínima. Esta métrica definiría la suma de cuadrados interna, o WCSS.

21 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Por ello, todo lo anterior se resume de la siguiente forma: la mejor calidad de clustering se
obtendría cuando todos los puntos estén lo más cerca posible a un centroide determinado, de
manera que se minimice la SSwihin o WCSS, que se obtendría de sumar todas las WCSS
resultantes de cada clúster.

Para un ejemplo de 3 clústers como el siguiente sería:

Ilustración 6 Propuesta de clusters para los datos mostrados de ejemplo

𝑊𝐶𝑆𝑆 = ∑ 𝑑(𝑃𝑖 , 𝐶1 )2 + ∑ 𝑑(𝑃𝑖 , 𝐶2 )2 + ∑ 𝑑(𝑃𝑖 , 𝐶3 )2

𝑃𝑖 ∈𝐶1 𝑃𝑖 ∈𝐶2 𝑃𝑖 ∈𝐶3

Y de forma genérica, el problema a resolver sería encontrar el mejor número de clusters K tales
que:

© Structuralia 22
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

𝑚𝑖𝑛(𝑊𝐶𝑆𝑆)

2
𝑐𝑜𝑛 𝑊𝐶𝑆𝑆 = ∑ ∑ 𝑑(𝑃𝑖 , 𝐶𝑗 )
𝑗 𝑃𝑖 ∈𝐶𝑗

El problema que aparece es que la situación que minimizaría WCSS se daría cuando K = Nº de
datos, ya que ahí cada dato sería un propio cluster debido a que en ese caso d(P, C) = 0, y esto,
aunque matemáticamente sea correcto no tiene mucha utilidad práctica.

De esta manera, el método del codo propone representar gráficamente cómo se va reduciendo
el WCSS en función del valor de K usado y elegir como valor de referencia K aquél a partir del
cual aunque aparezcan reducciones de WCSS, que estas ya sean unas reducciones poco
significativas.

Ilustración 7 Como no se quiere un K muy alto, se elige ese punto a partir del cual WCSS no varía mucho más.

De esta forma se suele utilizar este sistema como primer paso antes de aplicar definitivamente
un algoritmo de clustering que necesita tener predefinido el número de clústers K, como ocurre
con K-Means.

23 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Métrica Silhouette

Método para evaluar la consistencia de los clusters, ya que da una estimacion de como de bien
encajan los puntos en cada uno de ellos midiendo como de parecidos son los puntos de dentro de un
cluster y como de diferentes son de los demás (intuición similar a lo visto hasta ahora).

La métrica silhouette se expresa de la siguiente manera para un punto en concreto:

𝑝−𝑞
𝑠𝑖𝑙ℎ𝑜𝑢𝑒𝑡𝑡𝑒 𝑠𝑐𝑜𝑟𝑒 =
max (𝑝, 𝑞)

𝑐𝑜𝑛 𝒑 𝑙𝑎 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 𝑚𝑒𝑑𝑖𝑎 𝑎 𝑙𝑜𝑠 𝑝𝑢𝑛𝑡𝑜𝑠 𝑑𝑒𝑙 𝑐𝑙𝑢𝑠𝑡𝑒𝑟 𝑚𝑎𝑠 𝑐𝑒𝑟𝑐𝑎𝑛𝑜 𝑑𝑒 𝑙𝑜𝑠 𝑞𝑢𝑒 𝑒𝑙 𝑝𝑢𝑛𝑡𝑜 𝑒𝑛 𝑐𝑢𝑒𝑠𝑡𝑖ó𝑛

𝑛𝑜 𝑓𝑜𝑟𝑚𝑎 𝑝𝑎𝑟𝑡𝑒 𝑦 𝒒 𝑙𝑎 𝑚𝑒𝑑𝑖𝑑𝑎 𝑑𝑒 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 𝑖𝑛𝑡𝑟𝑎𝑐𝑙𝑢𝑠𝑡𝑒𝑟 𝑟𝑒𝑠𝑝𝑒𝑐𝑡𝑜 𝑎 𝑙𝑜𝑠 𝑝𝑢𝑛𝑡𝑜𝑠 𝑑𝑒𝑛𝑡𝑟𝑜 𝑑𝑒 é𝑙

El valor de esta métrica estará entre -1 y 1. Cuanto más cercana sea a 1 más se asemeja el punto en
cuestión a los del clúster, y cuanto más cercana a -1 más se diferencia. SI el valor es cercano a 0 se
debe a que algunos clusters se solapan.

La métrica de la Silhouette como tal va a descender por lo general a medida que aumente el número
de clústers. Por este motivo lo normal es elegir un número de clústers adecuado antes de que la
métrica empiece a empeorar en exceso.

Métricas BIC y AIC

Las métricas AIC (Akaike Information Criterion) y BIC (Bayesian Information Criterion) también
aplican al cálculo del número de clústers (ya que penalizan usar muchos parámetros, en este
caso usar muchos clusters). Junto a ellas aparece también la DIC (Deviance Information
Criterion) como aplicación de AIC a casos de clústering jerárquico.

© Structuralia 24
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

3. CLÚSTERING JERÁRQUICO, OTRAS TÉCNICAS Y EJEMPLOS

3.3 Clustering Jerárquico

Además de los algoritmos antes expuestos, existe otro tipo de algoritmos de clústering conocidos
como clústering jerárquico que permiten definir niveles de clústering sobre el conjunto de datos
de forma progresiva. Así, partiendo de los datos iniciales y de su matriz de distancia se obtienen
dichos niveles de agrupación. La agrupación puede ser aglomerativa (se va construyendo con
clústers cada vez más grandes) o divisiva (se parte de un clúster grande que se va dividiendo en
clústers más pequeños).

Estos niveles de agrupación se reflejan en lo que se conoce como dendograma, que representa
la jerarquía de los distintos clústers generados, y permiten explorarlos a distintos niveles de
granularidad.

Este proceso permite construir dichos niveles sin necesidad de conocer a priori el valor del
número de clúster k.

Aglomerativo

En el clústering jerárquico aglomerativo, o clústering AGNES (agglomerative nesting) se parte de

una situación inicial donde se tienen tantos clústers como puntos de entrenamiento y se van
construyendo clústers hasta que se tiene un clúster final que engloba a todos los datos. El
algoritmo, por lo tanto, sigue los pasos expuestos a continuación:

1. Cada punto del dataset se convierte en un clúster. Se tienen así N clústers donde N es el
número de datos que hay.

2. Se cogen los dos clústers más cercanos y se hace un clúster con ellos. Así se tienen N –
1 clústers.

3. Se cogen los siguientes dos clústers más cercanos y se hace un nuevo clúster. Así se
tienen N – 2 clústers3

4. Se repite el punto 3 hasta que sólo quede un clúster.

3 Eso ocurre en un tipo de clústers conocidos como binarios en los que no se agregan por paso más de
dos clústers a la vez (recordando que los puntos iniciales representaban un cluster cada uno, por eso
también se agregan solo 2 puntos)

25 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

De forma gráfica sería:

Ilustración 8 Situación inicial y primer paso. Se parte de que cada punto sería un clúster y la primera algomeración
sería combinar los puntos P2 y P3 dentro de un mismo clúster. Después, hacer lo mismo con P5 y P6. A la derecha
aparece la evolución del dendograma correspondiente.

© Structuralia 26
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 9 En los pasos siguientes se van combinando el resto de puntos y reduciendo el número de clústers.

Ilustración 10 Por último se tendría un único clúster que engloba ya a todos los puntos.

27 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Con el dendograma obtenido se puede elegir un valor de k clústers y ver a qué nivel de
agrupación correspondería. Para ello se traza una línea horizontal de forma que se corten a
tantas líneas verticales del dendograma como valor de k y tras hacer esto se desciende en el
dendograma desde esa línea de corte hasta llegar a las líneas horizontales. Esas líneas
horizontales determinan cómo estarían los puntos agrupados.

Ilustración 11 Teniendo el dendograma se puede elegir un número de clústers y en función de él se tendría una
agrupación u otra de los datos. Para K = 2 se tendrían dos agrupaciones que corresponderían a (P1, P2, P3) y a
(P4, P5, P6), mientras que con K = 3 serían (P1, P2, P3), (P4) y (P5, P6).

El eje y del dendograma representa la cercanía que tienen entre sí los clústeres padre con sus
clústeres hijo; es así un eje con distancias.

Divisivo4

El caso del algoritmo jerárquico divisivo, o DIANA (divisive analysis clustering), se procede de
forma inversa al caso anterior. Se parte de un único clúster y en cada paso se van dividiendo los
clústers hasta que se tenga un único clúster por dato del conjunto de datos. De nuevo, lo más
normal es que las divisiones sean binarias (es decir, que un clúster se divida sólo en otros 2).

4 Asignatura de Minería de Textos del Máster de IA de la UNED

© Structuralia 28
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

El esquema sería:

1. Se selecciona el clúster para dividir

▪ Se divide el clúster con más datos

▪ Se divide el clúster que al dividirlo de un resultado más óptimo para alguna función
objetivo

2. Se divide el cluster seleccionado en otros 2 (partición binaria)

3. Se repite el paso 1 hasta que haya un clúster por dato

Ventajas:

▪ El número óptimo de clústers se obtiene directamente desde el conjunto de datos.

▪ El dendograma aporta una visualización clara del proceso.

Desventajas:

▪ No es apropiado para conjuntos de datos muy grandes por ser un proceso

computacionalmente costoso.

El número óptimo de clusters se puede determinar trazando dos líneas horizontales y viendo
dónde podrían tener entre ellas el mayor espacio antes de llegar a alguna de las horizontales del
dendograma.

Ilustración 12 En este ejemplo la máxima línea vertical corresponde a esa indicada en azul, por lo que el número
óptimo de clusters sería 2.

29 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

3.4 Otros algoritmos

Aunque no se verán en detalle, existen otros algoritmos de clústering como los que se indican a
continuación.

Modelos de mezcla: Modelo de mezcla Gausiano (GMM)

https://towardsdatascience.com/gaussian-mixture-modelling-gmm-833c88587c7f

https://scikit-learn.org/stable/modules/mixture.html

Affinity Propagation

https://medium.com/@aneesha/using-affinity-propagation-to-find-the-number-of-clusters-in-a-
dataset-52f5dd3b0760

https://scikit-learn.org/stable/modules/generated/sklearn.cluster.AffinityPropagation.html

Algoritmo Mean-Shift

http://www.chioka.in/meanshift-algorithm-for-the-rest-of-us-python/

https://scikit-learn.org/stable/modules/generated/sklearn.cluster.MeanShift.html

Variational Bayesian Gaussian Mixture

https://zhiyzuo.github.io/VI/

https://scikit-learn.org/stable/modules/mixture.html#variational-bayesian-gaussian-mixture

Fuzzy Clustering

https://en.wikipedia.org/wiki/Fuzzy_clustering

https://www.cs.princeton.edu/courses/archive/fall08/cos436/Duda/C/fk_means.htm

https://home.deib.polimi.it/matteucc/Clustering/tutorial_html/cmeans.html

© Structuralia 30
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

3.5 Ejemplos

Ejemplo 1: K-Means Clustering

Para este ejemplo se va a utilizar el siguiente dataset disponible en Kaggle:

https://www.kaggle.com/ffisegydd/cluster-analysis-of-movies-data/data

Este contiene información sobre distintas películas, con los siguientes atributos:

▪ budget (presupuesto)

▪ company (compañía productora)

▪ country (país)

▪ director

▪ genre (género)

▪ gross (ingresos brutos)

▪ name (nombre)

▪ rating (calificación edades)

▪ released (fecha película)

▪ runtime (duración)

▪ score (puntación)

▪ star

▪ votes (número de votos de usuarios)

▪ writer

▪ year (año de la película)

Todos estos datos no tienen asociadas como tales unas categorías de salida, así que un tipo de
análisis que se podría utilizar es la segmentación usando algunos de los atributos para ver que
clústers se encuentran de películas que se consideren similares.

Para poder visualziar el problema se cogen dos únicas variables para tener un problema
bidimensional. Podría interesar, por ejemplo, ver cómo se agrupan las películas en función del
presupuesto que han recibido y de acuerdo con los ingresos que han obtenido después. Para el
caso de 3 clústers quedaría.

31 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

# -*- coding: utf-8 -*-

# K-Means Clustering

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

# Dataset

dataset = pd.read_csv('movies.csv', encoding='latin-1')

X = dataset[["budget", "gross"]].values

# K-Means

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters = 3, init= 'k-means++', max_iter = 300, n_init = 10, random_state = 0)

y_kmeans = kmeans.fit_predict(X) # fit_predict devuelve para cada punto a que cluster pertenece

### Visualizar clusters (se pintan uno a uno)

# Con esto lo que se hace es especificar que se quiere aplicar esto a los puntos del Cluster 1 (index=0),

# y para la columna 0 (la de los valores de X) y la 1 (la de los valores de y) de esos puntos

# Es decir, en X se tienen dos columnas, se coge la de X (x[0]) y la de y (X[1]) pero aplicado a los puntos
de cada cluster

# (es decir, en vez de todas las filas con [:,] cojo solo las de un cluster [y_label == i])

plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'blue', label = 'C1')

plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'red', label = 'C2')

plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green', label = 'C3')

plt.scatter(X[y_kmeans == 3, 0], X[y_kmeans == 3, 1], s = 100, c = 'cyan', label = 'C4')

plt.scatter(X[y_kmeans == 4, 0], X[y_kmeans == 4, 1], s = 100, c = 'magenta', label = 'C5')

© Structuralia 32
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

# Para pintar los centroides

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s = 300, c = 'yellow', label =

'Centroides')

plt.title('Clusters de Películas')

plt.xlabel('X1: Presupuesto ($)')

plt.ylabel('X2: Ingresos ($)')

plt.legend()

plt.show()

Esto podría ser interesante ya que podría ayudar a un inversor de cine a elegir en qué tipo de
películas invertir según sus intereses.

El valor de n_init del algoritmo de KMeans corresponde a las veces que se va a ejecutar el mismo
algoritmo pero con semillas distintas para tener centroides en posiciones diversas, de forma que
se gane aun más precisión en la ubicación de los centroides iniciales.

33 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ejemplo 2: K-Means Clustering

Otro ejemplo de clustering se puede llevar a cabo con los datos de Kaggle del dataset
https://www.kaggle.com/arjunbhasin2013/ccdata que contiene información sobre balances de
cuentas y transacciones de clientes. El conjunto de datos contiene muchos campos pero
especialmente interesan para este ejemplo los siguientes:

▪ BALANCE: Balance actual de la cuenta ($)

▪ PURCHASES: Gasto en compras ($)

Así, con estos datos se podría simular a una entidad bancaria que hace un análisis de sus clientes
para poderles dirigir posteriormente campañas de marketing concretas.

Para ello el código sería:

# -*- coding: utf-8 -*-

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

# Dataset

dataset = pd.read_csv('CC GENERAL.csv', encoding='utf-8')

X = dataset[["BALANCE", "PURCHASES"]].values

# K-Means

from sklearn.cluster import KMeans

kmeans = KMeans(n_clusters = 5, init= 'k-means++', max_iter = 300, n_init = 10, random_state = 0)

y_kmeans = kmeans.fit_predict(X)

© Structuralia 34
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

### Visualizar clusters (se pintan uno a uno)

plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'blue', label = 'C1')

plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'red', label = 'C2')

plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green', label = 'C3')

plt.scatter(X[y_kmeans == 3, 0], X[y_kmeans == 3, 1], s = 100, c = 'cyan', label = 'C4')

plt.scatter(X[y_kmeans == 4, 0], X[y_kmeans == 4, 1], s = 100, c = 'magenta', label = 'C5')

# Para pintar los centroides

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s = 300, c = 'yellow', label =

'Centroides')

plt.title('Clusters de Clientes')

plt.xlabel('X1: Balance en la Cuenta ($)')

plt.ylabel('X2: Gastos en Compras ($)')

plt.legend()

plt.show()

35 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Esta segmentación ayuda a conocer a los clientes que se tienen; asi, se puede descubrir como
hay un primer sector de clientes (azul) con poco dinero en la cuenta y que realizan pocas compras
(podría ser porque no tengan mucho poder adquisitivo o porque la cuenta en este banco sea una
cuenta adicional que no usan mucho), otro sector que suele hacer movimientos con su cuenta y
que tiene unos rangos de ahorros que varian dentro de una franja bastante amplia (verde) con lo
que parece que esta podría ser una de sus cuentas de uso habitual, otro sector con mucha
dispersión y que gasta una gran cantidad de dinero pero que a la vez tiene balances en cuenta
que llegan a ser muy altos (azul claro), y otros dos sectores con muchos ahorros pero que
realizan pocas transacciones, dándose a entender que podrían ser cuentas ahorro (morado y
rojo).

Con ello, un banco con esta información tendría ya segmentados a sus clientes y podría dirigir
para cada uno de ellos campañas distintas. Por ejemplo, para fidelizar a los clientes en C2 podría
ofrecer mejores planes de cuentas ahorro (más intereses…), mientras que para los clientes en
C4 podría ofrecer condiciones mejores de cuenta nómina, dirigirles campañas de financiación
para ayudarles más con sus compras…

Ejemplo 3: Clustering Jerárquico

Para este problema se usarán los mismos datos de clientes de tbancarios usados previamente.

###############################################################################

# Clustering Jerárquico

###############################################################################

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

© Structuralia 36
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

# Dataset

dataset = pd.read_csv('CC GENERAL.csv', encoding='utf-8')

X = dataset[["BALANCE", "PURCHASES"]].values

### Dendograma para tener el numero optimo de clusters

# Se va a usar a usar una librería nueva, y con ello busco ver el numero optimo de clusters

import scipy.cluster.hierarchy as sch

# Se usa el metodo 'ward' que intenta minimizar la varianza entre clusters.

# En lugar de minimizar el WC minimal square, se hace con la varianza -> minimizar la varianza en cada
cluster

dendrogram = sch.dendrogram(sch.linkage(X, method = 'ward'))

plt.title('Dendrograma')

plt.xlabel('Clientes')

plt.ylabel('Distancias Euclideas')

plt.show()

37 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

El dendograma ayuda a ver visualmente que un numero representativo de clusters es 3. Con ello
se entrenaría el sistema de la siguiente forma.

# Entrenar el algoritmo con los datos del conjunto

from sklearn.cluster import AgglomerativeClustering

hc = AgglomerativeClustering(n_clusters = 3, affinity = 'euclidean', linkage = 'ward')

y_hc = hc.fit_predict(X) # Con fit_predict se obtiene el cluster asignado a cada punto

Y para visualizarlo sería:

### Visualizar clusters (se pintan uno a uno)

plt.scatter(X[y_hc == 0, 0], X[y_hc == 0, 1], s = 100, c = 'blue', label = 'C1')

plt.scatter(X[y_hc == 1, 0], X[y_hc == 1, 1], s = 100, c = 'red', label = 'C2')

plt.scatter(X[y_hc == 2, 0], X[y_hc == 2, 1], s = 100, c = 'green', label = 'C3')

# Para pintar los centroides

plt.scatter(hc.cluster_centers_[:, 0], hc.cluster_centers_[:,1], s = 300, c = 'yellow', label = 'Centroides')

plt.title('Clusters de Clientes')

plt.xlabel('X1: Balance en la Cuenta ($)')

plt.ylabel('X2: Gastos en Compras ($)')

plt.legend()

plt.show()

© Structuralia 38
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

El visualizarlo con 3 clusters ayuda a tener segmentados a los clientes dentro de unas categorías
más representativas: por un lado los clientes que usan poco la cuenta (C2), los que la usan como
cuenta ahorro (C3) y los que la usan para compras o gastos habituales (C1).

Ejemplo 4: K-Means con selección del número óptimo de clústers (Elbow Method)

Para el mismo conjunto de datos de transacciones bancarias se propone ahora usar el mismo
algoritmo K-Means pero usando previamente el método del codo, o Elbow Method, para
encontrar cuál es el número óptimo de clústers K.

En primer lugar, como siempre, se cargan los datos:

# -*- coding: utf-8 -*-

###############################################################################

# K-Means Clustering

39 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

###############################################################################

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

El siguiente paso sería definir una función para calcular y poder visualizar el número óptimo de
clústers usando el Elbow Method. Existen librerías para ello, pero debido a que es una función
sencilla de desarrollar se va a construir manualmente.

### Elbow Method

from sklearn.cluster import KMeans

def elbow_method(epsilon, X, figure=False):

wcss = [] # Pongo un vector a 0 para ver los distintos wcss segun el numero de clusters que defina

diff = np.inf # Valor de diferencia entre dos iteraciones

i_init = 2

i = i_init

while diff > epsilon:

print("Iteracion Nº Clusters: k: {k}".format(k=i))

# Con init=k-means++ y con n_init defino que quiero usar la opcion de ++

# (que tiene en cuenta la posicion inicial y su influencia)

# y que tome 10 posiciones iniciales para comparar

kmeans = KMeans(n_clusters = i,

© Structuralia 40
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

init = 'k-means++',

max_iter = 300,

n_init = 10,

random_state = 0)

kmeans.fit(X)

# Primera iteracion

if diff == np.inf:

diff = kmeans.inertia_

# Si ya fuese 0

elif kmeans.inertia_ == 0:

wcss.append(kmeans.inertia_)

break

# Resto de iteraciones

else:

diff = (wcss[-1] - kmeans.inertia_)/wcss[-1]

wcss.append(kmeans.inertia_)

i += 1

if figure:

plt.plot(range(i_init,len(wcss)+i_init), wcss)

plt.title('Elbow Method')

plt.xlabel('Número de Clústers')

plt.ylabel('WCSS')

plt.show()

# Clusters finales

k = i-1

41 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

return wcss, k

# Dataset

dataset = pd.read_csv('CC GENERAL.csv', encoding='utf-8')

X = dataset[["BALANCE", "PURCHASES"]].values

La variable intertia_ del objeto creado para el algoritmo de kmeans contiene el valor del WCSS.

Definida esta función se visualiza primero el elbow method especificando un valor de épsilon
reducido.

# Visualizacion de los resultados

epsilon = 0.05 # Valor umbral

wcss, _ = elbow_method(epsilon, X, figure=True)

Se puede apeciar como el valor óptimo estaría entre el 2 y el 5, ya que a partir de ahí no baja
WCSS de forma tan significativa.

Este valor de K se podría obtener directamente usando un valor de épsilon más elevado; por
ejemplo, elegir el valor de K cuando la reducción de WCSS sea menor del 33% del valor anterior.

© Structuralia 42
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

# Obtencion de la k optima

epsilon = 0.33

_, k = elbow_method(epsilon, figure=False)

Con ello se obtendría un valor de K = 4 y se podría proceder a representar los resultados tras
entrenar un modelo con estos valores.

# K-means

kmeans = KMeans(n_clusters = k, init= 'k-means++', max_iter = 300, n_init = 10, random_state = 0)

y_kmeans = kmeans.fit_predict(X)

### Visualizar clusters (se pintan uno a uno)

plt.scatter(X[y_kmeans == 0, 0], X[y_kmeans == 0, 1], s = 100, c = 'blue', label = 'C1')

plt.scatter(X[y_kmeans == 1, 0], X[y_kmeans == 1, 1], s = 100, c = 'red', label = 'C2')

plt.scatter(X[y_kmeans == 2, 0], X[y_kmeans == 2, 1], s = 100, c = 'green', label = 'C3')

plt.scatter(X[y_kmeans == 3, 0], X[y_kmeans == 3, 1], s = 100, c = 'cyan', label = 'C4')

# Para pintar los centroides

plt.scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:,1], s = 300, c = 'yellow', label =

'Centroides')

plt.title('Clusters de Clientes')

plt.xlabel('X1: Balance en la Cuenta ($)')

plt.ylabel('X2: Gastos en Compras ($)')

plt.legend()

plt.show()

43 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ahora, con 4 clusters, se ve que además de las reflexiones para los grupos C1, C3 y C4 (que
serían análogas a las del ejercicio anterior) aparece otro cluster significativo C2 que podría
representar un tipo de usuario que usa de forma habitual su tarjeta, que se diferencia del otro
cluster C4 en que sus ingresos y gastos son posiblemente menores.

Ejemplo 5: K-Means con selección del número óptimo de clústers (Silhouette)

Para el mismo conjunto de datos de los balances de cuentas, se selecciona el número de K en

función de la métrica de la Silhouette.

En este caso, como la métrica desciende siempre, pero el que descienda es potencialmente un
hecho negativo, se itera hasta que el descenso sea muy pronunciado (por encima de un valor de
referencia), momento en el que se deja de iterar y se selecciona el valor de K de la anterior
iteración como mejor valor.

# -*- coding: utf-8 -*-

###############################################################################

# K-Means Clustering

© Structuralia 44
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

###############################################################################

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

### Silhouette Score

from sklearn.cluster import KMeans

from sklearn import metrics

def silhouette_selection(referencia, X, figure=False):

"""

En este caso se usa un valor de referencia para detenerse cuando la diferencia de usar un k u otro

sea muy significativa (ya que querria decir que ha empeorado mucho el modelo)

"""

shc = [] # Pongo un vector a 0 para ver los distintos scores segun el numero de clusters que defina

diff = 0

i=1

valores = []

while abs(diff) < referencia:

i += 1 # Esta metrica necesita al menos 2 clusters

valores.append(i)

print("Iteracion Nº Clusters: k: {k}".format(k=i))

kmeans = KMeans(n_clusters = i, init = 'k-means++', max_iter = 300, n_init = 10, random_state = 0)

45 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

kmeans.fit(X)

score = metrics.silhouette_score(X, kmeans.labels_, metric="euclidean", sample_size=len(X))

# Primera iteracion

if i == 2:

pass

# Resto de iteraciones

else:

diff = (shc[-1] - score)/shc[-1]

shc.append(score)

print("Silhouette score = {0} para Nº Clusters {1}".format(score, i))

print("Diferencia con el score anterior", diff)

if figure:

plt.figure()

plt.bar(valores, shc, width=0.7, color='blue', align='center')

plt.title('Silhouette Score vs Numero de Clusters')

plt.show()

# Clusters finales

k = i-1

return shc, k

# Dataset

dataset = pd.read_csv('CC GENERAL.csv', encoding='utf-8')

X = dataset[["BALANCE", "PURCHASES"]].values

# Obtencion de k optima

referencia = 0.15

© Structuralia 46
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

shc, k = silhouette_selection(referencia, X, figure=True)

# K-means

kmeans = KMeans(n_clusters = k, init= 'k-means++', max_iter = 300, n_init = 10, random_state = 0)

y_kmeans = kmeans.fit_predict(X)

Y se encontraría como óptimo el valor de K = 4, coincidiendo así con los resultados obtenidos en
el Elbow Method.

Visualizaciones de Clustering

Las visualizaciones de clustering que hemos visto, en las que se representaban los puntos de
datos en función del cluster al que pertenecen, estaban limitadas a 2D. El problema con ello es
que no permiten visualizar clusters de más de 2 variables.

Sin embargo, existen otro tipo de visualizaciones que sí permiten ver los distintos clusters
independientemente del número de dimensiones.

47 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Un ejemplo de ello es el Radar Chart (o Spider Chart), en el que se representan múltiples

coordenadas con el valor del centroide de cada cluster para esa variable
(https://en.wikipedia.org/wiki/Radar_chart#:~:text=A%20radar%20chart%20is%20a,starting%20
from%20the%20same%20point.)

La implementación en Python no es directa, pero se puede ver cómo hacerla aquí: https://python-
graph-gallery.com/391-radar-chart-with-several-individuals/

© Structuralia 48
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

4. ANÁLISIS DE COMPONENTES PRINCIPALES (PCA)

4.6 Introducción

El análisis de componentes principales o PCA por sus siglas en inglés (principal component
análisis) es una técnica de aprendizaje no supervisado que se engloba dentro de un subconjunto
de técnicas denominadas como técnicas de extracción de rasgos (feature extraction). Estas
técnicas tienen en común partir del conjunto de datos de entrada y generar unas variables
artiifciales nuevas, generalmente un número de ellas menor que el de las variables de entrada,
que serían las que se usasen posteriormente con otros algoritmos (por ejemplo, de clasificación)
buscando obtener unos resultados más precisos.

Estas técnicas se diferencian de otro grupo conocido como técnicas de selección de rasgos
(feature selection) que se encargan no de crear nuevas variables artificiales sino seleccionar las
variables originales más relevantes y descartar las demás para simplificar el problema. Estas
técnicas ya han aparecido en el capítulo de aprendizaje supervisado, en concreto por ejemplo
con las técnicas de regularización de los algoritmos de regresión. Aun así, se puede profundizar
en ellas si se desea desde referencias como la de Scikit-Learn: https://scikit-
learn.org/stable/modules/feature_selection.html

La intuición detrás de todo esto es la siguiente; para muchos casos de uso aparecen una gran
cantidad de variables y puede que ocurra que no todas sean relevantes igual de relevantes para
explicar cómo varían los datos (por ejemplo, una variable que valga siempre lo mismo no aporta
información para diferenciar unos puntos de otros; de igual forma, dos variables que estén muy
correladas hace que una de ellas no sea necesaria para explicar los datos). De esta forma, el
algoritmo PCA trata de resumir la información que extrae de los datos originales en varias
variables artificiales que expliquen de forma condensada lo que está ocurriendo en los datos.
Así, para construir dichas variables se fijará en las variables que más varíen de entre todas las
variables presentes en los datos de entrada. Por tanto, es importante tener en cuenta la varianza
de estas. Con ello se construirán dichas variables artificiales de manera que guarden relación
con las variables originales.

49 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Por ejemplo, si se quiere predecir el precio de una vivienda y se dispone de variables como
{tamaño, nº habitaciones, ubicación, antigüedad, color de la fachada} el algoritmo de PCA
detectaría que no todas las variables son igualmente importantes; por ejemplo, se debería
encontrar que el color de la fachada no sería una variable relevante por no ser un dato que
tuviese una gran variación en función del precio de vivienda. Por otro lado, podría detectar como
el número de habitaciones y el tamaño son variables que seguramente tengan una correlación y
por lo tanto se podría construir una variable artificial nueva que recogiese la relación (lineal) que
existiría entre ellas.

Como se ha visto en el apartado de regresión lineal, la mejor relación entre las variables será
aquella que minimice el error de los puntos respecto a la recta de regresión construida.

Ilustración 13 Dos ejemplos de rectas de regresión. En el caso de la derecha el error es menor que en el de la
izquierda

La búsqueda de minimización del error coincide con la búsqueda de la recta de regresión que
maximice la varianza de los puntos originales proyectados de forma ortogonal sobre ella.

© Structuralia 50
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 101 Para las dos rectas de regresión se puede ver como la de la derecha (la del error mínimo) es la que
tiene mayor varianza en los puntos proyectados (indicados en rojo).5

De forma genérica, el algoritmo PCA parte de un conjunto de p variables iniciales (que podrían
estar correladas) y busca obtener p variables nuevas no correladas, denominadas componentes
principales. Estas variables nuevas tendrán asociado un peso que indicará su importancia
relativa, de manera que se podrán elegir las más significativas para trabajar posteriormente con
un problema de dimensionalidad reducida.

Así, se partiría de una matriz de observaciones de tamaño n donde cada fila sea una observación
y cada columna corresponda al valor de una determinada variable para dicha observación.

𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠 𝑜𝑟𝑖𝑔𝑖𝑛𝑎𝑙𝑒𝑠: 𝑥1 , 𝑥2 , … , 𝑥𝑃 → 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠 𝑡𝑟𝑎𝑛𝑠𝑓𝑜𝑟𝑚𝑎𝑑𝑎𝑠: 𝑦1 , 𝑦2 , … , 𝑦𝑝

Esta transformación se hace mediante una matriz de datos 𝑋 (𝑛 𝑥 𝑝) tal que:

𝑌 = 𝑤 𝑇 𝑋 = 𝑤1 𝑥1 + 𝑤2 𝑥2 + ⋯ + 𝑤𝑝 𝑥𝑝

5Fuente: https://stats.stackexchange.com/questions/2691/making-sense-of-principal-component-analysis-
eigenvectors-eigenvalues/15195

51 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

De forma que el vector de pesos sería:

𝑇
𝑤 = (𝑤1 , 𝑤2 , … , 𝑤𝑝 )

Y como es un vector de pesos cumpliría que:

𝑤12 + 𝑤22 + ⋯ + 𝑤𝑝2 = 1

Ahora bien, quedaría determinar los valores de dichos coeficientes entrenando el modelo. Como
se ha visto previamente, las mejores componentes nuevas serán aquellas que maximicen la
varianza de las variables originales. Por lo tanto, estos pesos se determinarán gracias a la matriz
de varianzas-covarianzas de los datos de X:

𝜎12 … 𝑆1𝑝
Σ= [… … …]
2
𝑆𝑝1 … 𝜎𝑝

Para obtener los valores de w el primer paso consistiría en calcular los autovalores y autovectores
de la matriz de covarianzas ya que los autovectores de dicha matriz contendrán la dirección de
proyección de la nueva variable artificial que maximice la varianza de los datos:

det(𝛴 − 𝜆𝐼) = 0

𝛴 = 𝐴 𝐷 𝐴𝑇

𝜆1 0 ⋯ 0
𝐷 = (⋮ 𝜆2 ⋱ ⋮)
0 0 ⋯ 𝜆𝑝

© Structuralia 52
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ejemplo:

Para un caso sencillo de 2 variables con la siguiente matriz de covarianza:

1 4
Σ= ( )
4 1
1− 𝜆 4
det(𝛴 − 𝜆𝐼) = | |=0→
4 1−𝜆

→ 𝑟𝑒𝑠𝑜𝑙𝑣𝑖𝑒𝑛𝑑𝑜 𝑒𝑙 𝑑𝑒𝑡𝑒𝑟𝑚𝑖𝑛𝑎𝑛𝑡𝑒 𝑠𝑒 𝑜𝑏𝑡𝑖𝑒𝑛𝑒𝑛 𝑙𝑎𝑠 𝑑𝑜𝑠 𝑠𝑜𝑙𝑢𝑐𝑖𝑜𝑛𝑒𝑠 𝑑𝑒 𝜆

(1 − 𝜆)(1 − 𝜆) − 8 = 0 →

→ 𝜆1 = 1 + 4 = 5

→ 𝜆2 = 1 − 4 = −3

𝐴𝑠í → 𝜆1 > 𝜆2

Se calcularían con ello los autovectores:

𝐶𝑜𝑛 𝜆 = 5

𝑥 𝑥
(Σ − 𝜆I) (𝑦) = (Σ − 5I) (𝑦) = (0) →
0
−4 4 𝑥 0
→ ( ) (𝑦) = ( ) → 𝑥 − 𝑦 = 0 → 𝑥 = 𝑦
4 −4 0
1
𝑆1 = 𝑔𝑒𝑛 {( ) } 𝑠𝑖𝑒𝑛𝑑𝑜 𝑒𝑠𝑎 𝑙𝑎 𝑏𝑎𝑠𝑒 𝑑𝑒𝑙 𝑠𝑢𝑏𝑒𝑠𝑝𝑎𝑐𝑖𝑜 𝑑𝑒 𝑠𝑜𝑙𝑢𝑐𝑖𝑜𝑛𝑒𝑠
1

𝑃𝑜𝑟 𝑙𝑜 𝑞𝑢𝑒 𝑢𝑛 𝑎𝑢𝑡𝑜𝑣𝑒𝑐𝑡𝑜𝑟 𝑠𝑒𝑟í𝑎: 𝑣1 = √2

1
(√2)

53 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

𝐶𝑜𝑛 𝜆 = −3

𝑥 𝑥
(Σ − 𝜆I) (𝑦) = (Σ + 3I) (𝑦) = (0) →
0
4 4 𝑥 0
→ ( ) (𝑦) = ( ) → 𝑥 + 𝑦 = 0 → 𝑥 = −𝑦
4 4 0
1
𝑆2 = 𝑔𝑒𝑛 {( ) } 𝑠𝑖𝑒𝑛𝑑𝑜 𝑒𝑠𝑎 𝑙𝑎 𝑏𝑎𝑠𝑒 𝑑𝑒𝑙 𝑠𝑢𝑏𝑒𝑠𝑝𝑎𝑐𝑖𝑜 𝑑𝑒 𝑠𝑜𝑙𝑢𝑐𝑖𝑜𝑛𝑒𝑠
−1

𝑃𝑜𝑟 𝑙𝑜 𝑞𝑢𝑒 𝑢𝑛 𝑎𝑢𝑡𝑜𝑣𝑒𝑐𝑡𝑜𝑟 𝑠𝑒𝑟í𝑎: 𝑣2 = √2

−1
( √2 )

Como 𝜆1 > 𝜆2 se elegiría el autovalor de ese vector como vector de pesos para la nueva
variable, de forma que:

1 1
𝑦1 = 𝑥1 + 𝑥2
√2 √2

Debido a que los autovectores son ortogonales, la segunda componente, que correspondería al
segundo autovector, sería:

1 1
𝑦2 = 𝑥1 − 𝑥2
√2 √2

© Structuralia 54
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 14 Visualización de los vectores de las componentes principales correspondientes a los autovectores de
la matriz de covarianzas.

Las nuevas variables Y definidas tendrán una varianza igual a los autovalores obtenidos
previamente. Así:

𝑣𝑎𝑟(𝑦𝑖 ) = 𝜆𝑖

De esta forma los valores de 𝜆 servirán para entender cómo van a evolucionar los valores de 𝑦𝑖 .
Si 𝜆𝑖 es bajo implicará que la varianza es pequeña y que por tanto los datos cambiarán poco en
la dirección determinada por la nueva variable 𝑦𝑖 .

Para poder comparar la influencia relativa de las distintas componentes principales se pueden
comparar las varianzas explicadas, que se calculan como:

𝜆𝑖
𝑣𝑎𝑟𝑖𝑎𝑛𝑧𝑎 𝑒𝑥𝑝𝑙𝑖𝑐𝑎𝑑𝑎 (𝑖) = 𝑁
∑𝑗 𝜆𝑗

55 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Esta varianza explicada calculada para cada componente ayuda a determinar cuáles serán
relevantes y cuáles no. Existen varios criterios que se pueden tomar para elegir qué componentes
serían significativas:

▪ Elegir sólo las que tienen una autovalor superior a 0.5 o 0.7

▪ Elegir sólo las que tienen un autovalor superior a 1 (kaiser criterion)

▪ Elegir PCs hasta tener una varianza explicada entorno a 0.5 ~ 0.7

▪ Se pueden representar las distintas componentes en función de sus valores y elegir un

punto de referencia a partir del cuál se descartarían las restantes (scree plot)

Ilustración 15 Ejemplo de Scree Plot6

4.7 Definición algebráica7

La justificación matemática que relaciona el vector de pesos con los autovectores de la matriz de
covarianzas es la siguiente:

6Fuente:https://support.minitab.com/en-us/minitab/18/help-and-how-to/modeling-

statistics/multivariate/how-to/factor-analysis/interpret-the-results/all-statistics-and-graphs/
7 Justificación matemática extraída de los Apuntes de la asignatura de Minería de Datos del Máster en

Ingeniería de Sistemas de Decisión de la URJC

© Structuralia 56
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

𝑣𝑒𝑐𝑡𝑜𝑟 𝑑𝑒 𝑑𝑎𝑡𝑜𝑠 𝑖𝑛𝑖𝑐𝑖𝑎𝑙 → 𝑥 = (𝑥1 , 𝑥2 , … , 𝑥𝑝 )

𝑝

𝑝𝑟𝑖𝑚𝑒𝑟𝑎 𝑐𝑜𝑚𝑝𝑜𝑛𝑒𝑛𝑡𝑒 → 𝑦1 = 𝑤1𝑇 𝑋 = ∑ 𝑤𝑖1 𝑥𝑖 𝑐𝑜𝑛 𝑤1 = (𝑤11 , 𝑤21 , … , 𝑤𝑝1 )

𝑖=1

Se elige esa componente de forma que:

𝑣𝑎𝑟[𝑦1 ] 𝑠𝑒𝑎 𝑚á𝑥𝑖𝑚𝑎

Sabiendo que las componentes principales son independientes:

𝑐𝑜𝑣[𝑦𝑗 , 𝑦𝑘 ] = 0 𝑐𝑜𝑛 𝑗 > 𝑘 ≥ 1

𝑐𝑜𝑛 𝑤𝑗𝑇 𝑤𝑗 = 1

La varianza de la primera componente principal se define como:

𝑣𝑎𝑟[𝑦1 ] = 𝐸[𝑦12 ] − 𝐸[𝑦1 ]2

Operando la expresión anterior se obtiene que:

𝑝 𝑝 𝑝
𝑣𝑎𝑟[𝑦1 ] = 𝐸[𝑦12 ] − 𝐸[𝑦1 ]2 = ∑𝑖,𝑗=1 𝑤𝑖1 𝑤𝑗1 𝐸[𝑥𝑖 𝑥𝑗 ] − ∑𝑖,𝑗=1 𝑤𝑖1 𝑤𝑗1 𝐸[𝑥𝑖 ]𝐸[𝑥𝑗 ] = ∑𝑖,𝑗=1 𝑤𝑖1 𝑤𝑗1 𝑆𝑖𝑗 =

= 𝑤1𝑇 𝑆 𝑤1

𝑐𝑜𝑛 𝑆 𝑙𝑎 𝑚𝑎𝑡𝑟𝑖𝑧 𝑑𝑒 𝑐𝑜𝑣𝑎𝑟𝑖𝑎𝑛𝑧𝑎𝑠 𝑝𝑎𝑟𝑎 𝑥

w1 se encontrará maximizando la varianza de dicha componente principal y1.

57 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

max 𝑣𝑎𝑟[𝑦1 ] 𝑠𝑢𝑗𝑒𝑡𝑜 𝑎 𝑤1𝑇 𝑤1 = 1

La expresión a maximizar equivaldría a:

𝑤1𝑇 𝑆 𝑤1 − 𝜆(𝑤1𝑇 𝑤1 − 1)

𝛿(𝑤1𝑇 𝑆 𝑤1 − 𝜆(𝑤1𝑇 𝑤1 − 1))

𝑚𝑎𝑥𝑖𝑚𝑖𝑧𝑎𝑟 → = 0 → (𝑆 − 𝜆𝐼)𝑤1 = 0
𝛿𝑤1

De esta forma se demuestra que dicho valor 𝜆 corresponde al primer valor propio de S 𝜆1 y que
w1 corresponde al primer vector propio.

Para obtener la siguiente componente principal y2 se maximizaría su varianza correspondiente:

max 𝑣𝑎𝑟[𝑦2 ] 𝑐𝑜𝑛 𝑐𝑜𝑣[𝑦2 , 𝑦1 ] = 0 𝑦 𝑐𝑜𝑛 𝑤2𝑇 𝑤2 = 1

La covarianza entre las componentes principales se expresa de la siguiente forma:

𝑐𝑜𝑣[𝑦2 , 𝑦1 ] = 𝑤1𝑇 𝑆 𝑤2 = ∅𝑤1𝑇 𝑤2 = 0

Y con todo lo anterior se puede escribir la ecuación:

𝑤2𝑇 𝑆 𝑤2 − 𝜆(𝑤2𝑇 𝑤2 − 1) − ∅𝑤2𝑇 𝑤1 = 0

Comprobándose así que w2 es otro vector propio de S. Este proceso se repetiría sucesivamente
para el resto de componentes principales.

Una nota final importante del algoritmo PCA es que los datos con los que trabaja deben estar
normalizados o estandarizados para que la construcción de variables nuevas sea eficiente (por
motivos similares a por qué se debe hacer en regresión lineal).

© Structuralia 58
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

4.8 Otros algoritmos de extracción de rasgos

Además del PCA, existen otros algoritmos para la extracción de rasgos que aunque no se
cubrirán en este curso sí que se indican a continuación referencias para poder conocerlos si se
desea.

Linear Discriminant Analysis (LDA)

Este algoritmo se aplica previamente a problemas de aprendizaje supervisado. De las n

variables independientes se extrae un número de ellas 𝑝 ≤ 𝑛 que separen el mayor número
posible de clases de la variable dependiente.

Así, propiamente, debido a que en este caso aparecen necesariamente variables dependientes
para extraer componentes se estaría propiamiente ante un modelo supervisado.

https://en.wikipedia.org/wiki/Linear_discriminant_analysis

https://sebastianraschka.com/faq/docs/lda-vs-pca.html

http://www.vfirst.com/blog/techfirst/dimension-reduction-techniques-pca-vs-lda-in-machine-
learning-part-2/

Kernel PCA

Los métodos anteriores sólo valen para problemas lineales (cuando los datos son linealmente
separables). Para generalizar a casos no linealmente separables se usa el algoritmo Kernel PCA
en el que, de forma similar a como se hacía en los problemas de regresión y clasificación
supervisada, se usa el truco del kernel para mapear a una dimensión superior y extraer en ella
las componentes principales con el PCA de manera que siendo lineales en ese espacio de
dimensión superior su proyección sobre el espacio original pueda ser no lineal.

http://www.cs.haifa.ac.il/~rita/uml_course/lectures/KPCA.pdf

https://scikit-learn.org/stable/auto_examples/decomposition/plot_kernel_pca.html

https://arxiv.org/pdf/1207.3538.pdf

59 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

5. EJERCICIO DE EJEMPLO PCA

Para este ejercicio se usará el conjunto de datos de Kaggle https://www.kaggle.com/c/house-
prices-advanced-regression-techniques/data que define un problema de regresión para predecir
el precio de viviendas en función de varios parámetros. En concreto de las 81 variables originales
se trabajará con el subconjunto siguiente (para hacer más comprensible el problema):

▪ MSSubClass: Clase/Categoría de la vivienda

▪ LotFrontage: Metros lineales de calle conectados a la propiedad

▪ LotArea: Area del terreno en pies cuadrados

▪ GarageYrBlt: Año en que fue construido el garaje

▪ GarageCars: Capacidad del garaje (nº de vehículos que puede albergar)

▪ GarageArea: Tamaño del garaje en pies cuadrados

▪ WoodDeckSF: Deck area en pies cuadrados

▪ OpenPorchSF: Area abierta del porche en pies cuadrados

▪ EnclosedPorch: Area cubierta del porche en pies cuadrados

▪ ScreenPorch: Area acristalada del porche en pies cuadrados

▪ PoolArea: Tamaño de la piscina en pies cuadrados

▪ YrSold: Año de venta de la vivienda

▪ SalePrice: Precio de la vivienda

Con ello, en primer lugar se cargan los datos de las variables de entrada escogidas y la variable
de salida.

# -*- coding: utf-8 -*-

###############################################################################

# PCA

© Structuralia 60
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

###############################################################################

# Librerías

import numpy as np

import matplotlib.pyplot as plt

import pandas as pd

import seaborn as sns

### Data Preprocessing

# Dataset

dataset = pd.read_csv('house_prices.csv', encoding='utf-8')

# Eliminar columnas con NaN

dataset_f = dataset[["MSSubClass", "LotFrontage", "LotArea",

"GarageYrBlt", "GarageCars", "GarageArea",

"WoodDeckSF", "OpenPorchSF", "EnclosedPorch",

"ScreenPorch", "PoolArea", "YrSold", "SalePrice"]].dropna()

dataset_f.describe()

Y con ello se procede a analizar en primer lugar la matriz de correlaciones para ver si, como sería
previsible, hay altas correlaciones entre algunas variables.

f,ax = plt.subplots(figsize=(20,20))

sns.heatmap(dataset_f.corr(method='pearson'),annot=True,fmt=".1f",linewidths=1,ax=ax)

plt.show()

61 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Ilustración 16 Matriz de correlaciones. Se puede apreciar como algunas variables están altamente correladas (como
el tamaño del garaje y el número de plazas que tendría para vehículos, como cabría esperar)

© Structuralia 62
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Teniendo variables así correladas sería necesario quitarlas de cualquier modelo para que dicho
modelo fuese más sencillo y aumentase su generalidad. Ahora bien, esto mismo se podrá hacer
con el algoritmo PCA construyéndose las variables artificiales.

X = dataset_f.iloc[:, 0:len(dataset_f.columns)-1].values

y = dataset_f.iloc[:, len(dataset_f.columns)-1].values

# Train/Test Split

from sklearn.model_selection import train_test_split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.25, random_state = 0)

# Feature Scaling

from sklearn.preprocessing import StandardScaler

sc = StandardScaler()

X_train = sc.fit_transform(X_train)

X_test = sc.transform(X_test)

### PCA

from sklearn.decomposition import PCA

pca = PCA(n_components = None) # 'None' para que conserven en principio todas las PC

X_train_pca = pca.fit_transform(X_train)

X_test_pca = pca.transform(X_test)

"""

Se crea este vector para que diga la varianza explicada por cada escenario de PCAs y

ver que % de varianza explica cada componente.

63 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Se Extraen todas las indep. variables porque se ha puesto 'None', pero se tiene un vector

que ordena las que hay, el % que explican...

Se va sumando a medida que baja por el vector la varianza que explicaría si se cogen 2 variables, 3...

"""

explained_variance = pca.explained_variance_ratio_

print("Varianza Explicada por cada PC")

print(explained_variance)

var_exp = np.round(np.sum(explained_variance[0:5]),4)

print("Con 5 PC se explicaría el {var}% de la varianza".format(var=var_exp*100))

# Con los 5 ppales, se ve que el 65.3% de la varianza

Varianza Explicada por cada PC

[0.24854763 0.13893733 0.09496065 0.08854637 0.08198928 0.07560913

0.06740538 0.06345014 0.06113139 0.03850164 0.02926562 0.01165545]

Con 5 PC se explicaría el 65.3% de la varianza

Tras esto se puede especificar en el PCA que elija solo un numero predefinido de PC de la
siguiente forma:

# Se entrena solo para esas 5 componentes principales

pca = PCA(n_components = 5)

X_train_pca = pca.fit_transform(X_train)

X_test_pca = pca.transform(X_test)

explained_variance = pca.explained_variance_ratio_

print("Varianza Explicada por cada PC")

print(explained_variance)

print("Parámetros del Modelo")

© Structuralia 64
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

print(pca.components_)

# Visualizacion de las PC

sns.barplot(x='PC',y="var",

data=pd.DataFrame({'var':explained_variance,

'PC':['PC1','PC2','PC3','PC4', 'PC5']}), color="c")

Ilustración 17 Representación de la varianza explicada para cada PC

Con ello, se pueden usar las PC como variables para un modelo de regresión.

### Modelo de Regresión

# Con las PCA se construye un modelo de regresión

# Regresion Lineal

import statsmodels.api as sm

model = sm.OLS(y_train, X_train_pca).fit()

model.summary() # Se ve que la PC realmente relevante es solo la primera

65 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

# RF

from sklearn.ensemble import RandomForestRegressor

model = RandomForestRegressor(max_depth=5, random_state=0,

n_estimators=100)

model.fit(X_train_pca, y_train)

print("Relevancia de los parámetros")

print(model.feature_importances_) # Aparentemente con la primera componente artificial construida es

suficiente

Relevancia de los parámetros

[0.83549123 0.04545186 0.03010247 0.0459853 0.04296915]

En ambos casos se observa que la PC verdaderamente relevante para los modelos de regresión
es solamente la primera.

© Structuralia 66
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Las predicciones de este modelo serían:

# Predicciones

y_pred = model.predict(X_test_pca)

# Metricas de evaluacion

from sklearn.metrics import mean_squared_error, r2_score

r2 = r2_score(y_test, y_pred)

mae = mean_squared_error(y_test, y_pred)

print("r2: ", r2, "mae: ", mae)

r2: 0.46509156602258606 mae: 2302968682.6760144

Dado que se ha visto que el modelo necesita sólo esa primera PC, se entrena un modelo sólo
con ella.

# Usando solo 1 PC

pca = PCA(n_components = 1)

X_train_pca = pca.fit_transform(X_train)

X_test_pca = pca.transform(X_test)

explained_variance = pca.explained_variance_ratio_

print("Varianza Explicada por cada PC")

print(explained_variance)

print("Parámetros del Modelo")

print(pca.components_)

67 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Varianza Explicada por cada PC

[0.24854763]

Parámetros del Modelo

[[-0.10669997 0.29484302 0.20848705 0.41723899 0.49858494 0.51192037

0.25634904 0.26825166 -0.17215409 0.02624888 0.07399804 -0.0015978 ]]

model = RandomForestRegressor(max_depth=5, random_state=0,

n_estimators=100)

model.fit(X_train_pca, y_train)

y_pred = model.predict(X_test_pca)

r2 = r2_score(y_test, y_pred)

mae = mean_squared_error(y_test, y_pred)

print("r2: ", r2, "mae: ", mae) # Mejoran, de hecho, los resultados

r2: 0.4838564765524249 mae: 2222179152.0976634

Se observa que el modelo incluso gana generalidad obteniendo mejores métricas.

Por último, se podrían seleccionar 2 PC para representar gráficamente las mismas.

# Usando 2 PC para visualizar

pca = PCA(n_components = 2)

X_train_pca = pca.fit_transform(X_train)

X_test_pca = pca.transform(X_test)

explained_variance = pca.explained_variance_ratio_

print("Varianza Explicada por cada PC")

print(explained_variance)

print("Parámetros del Modelo")

print(pca.components_)

© Structuralia 68
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

Varianza Explicada por cada PC

[0.24854763 0.13893733]

Parámetros del Modelo

[[-0.10669997 0.29484302 0.20848705 0.41723899 0.49858494 0.51192037

0.25634904 0.26825166 -0.17215409 0.02624888 0.07399804 -0.0015978 ]

[-0.4555225 0.51928677 0.43502287 -0.34937079 -0.10860442 -0.03374627

-0.10764765 -0.08887951 0.28202868 0.10957175 0.29571177 -0.01107928]]

model = RandomForestRegressor(max_depth=5, random_state=0,

n_estimators=100)

model.fit(X_train_pca, y_train)

y_pred = model.predict(X_test_pca)

r2 = r2_score(y_test, y_pred)

mae = mean_squared_error(y_test, y_pred)

print("r2: ", r2, "mae: ", mae)

plt.scatter(X_train_pca[:,0], X_train_pca[:,1])

plt.ylabel("PC1")

plt.xlabel("PC2")

plt.title("Representación Gráfica de las PC")

plt.show()

69 © Structuralia
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

© Structuralia 70
 Data Mining, Machine Learning y Deep Learning - Aprendizaje no supervisado

6. REFERENCIAS
[1] https://en.wikipedia.org/wiki/Dartmouth_workshop

[2] https://en.wikipedia.org/wiki/Turing_test

[3] https://en.wikipedia.org/wiki/Chinese_room

[4] https://deepmind.com/research/alphago/

[5] http://www.ia.uned.es/~ejcarmona/publicaciones/[2013-Carmona]%20SVM.pdf

[6] https://www.semanticscholar.org/paper/Multi-class-Support-Vector-Machine-(SVM)-An-in-
and-Chamasemani-Singh/f830f53a30081ccd4e1f80983651afedd6e8459e

[7] http://scikit-learn.org/stable/auto_examples/svm/plot_svm_regression.html

[8] https://stackoverflow.com/questions/27564067/id3-decision-tree-clarification

[9] https://www.superdatascience.com/machine-learning/

[10] https://en.wikipedia.org/wiki/Naive_Bayes_spam_filtering

[11]http://wwwold.ece.utep.edu/research/webfuzzy/docs/kk-thesis/kk-thesis-html/node12.html

[12] https://www.cs.toronto.edu/~hinton/backprop.html

[13] https://www.tensorflow.org

71 © Structuralia