Contenido

1. K-means...............................................................................................................................................3
1.1. Funcionamiento y matemática detrás.........................................................................................3
1.2. Implementación...........................................................................................................................5
1.3. Aplicaciones.................................................................................................................................6
1.4. Parámetros..................................................................................................................................7
1.5. Ejemplo K-means segmentación de erupciones..........................................................................9
2. Afinity Propagation............................................................................................................................12
2.1. Funcionamiento y matemática detrás.......................................................................................12
2.1.1. Matriz de similitud:............................................................................................................13
2.1.2. Matriz de responsabilidad:................................................................................................15
2.1.3. Matriz de disponibilidad:...................................................................................................15
2.1.4. Matriz de criterios..............................................................................................................17
2.2. Aplicación..................................................................................................................................18
2.3. Parámetros................................................................................................................................18
2.4. Ejemplo con código....................................................................................................................19
3. Mean Shift.........................................................................................................................................20
3.1. Funcionamiento y matemática detrás.......................................................................................20
3.2. Aplicación..................................................................................................................................23
3.3. Parámetros................................................................................................................................24
3.4. Ejemplo de aplicación: segmentación de imágenes...................................................................25
4. Spectral clustering.............................................................................................................................28
4.1. Funcionamiento y matemática detrás.......................................................................................28
4.2. Aplicación..................................................................................................................................31
4.3. Parámetros................................................................................................................................31
4.4. Implementación.........................................................................................................................33
5. OPTICS...............................................................................................................................................38
5.1. Funcionamiento y matemática detrás.......................................................................................39
5.2. Aplicación..................................................................................................................................41
5.3. OPTICS VS DBSCAN....................................................................................................................43
5.4. Parámetros................................................................................................................................43
 1. K-means

El algoritmo K-means es un algoritmo iterativo que intenta dividir el conjunto de datos

en subgrupos (grupos) no superpuestos distintos definidos por Kpre donde cada punto
de datos pertenece a un solo grupo. Intenta hacer que los puntos de datos entre
clústeres sean lo más similares posible, al tiempo que mantiene los clústeres lo más
diferentes (lo más lejos posible). Asigna puntos de datos a un grupo de modo que la
suma de la distancia al cuadrado entre los puntos de datos y el centroide del grupo
(media aritmética de todos los puntos de datos que pertenecen a ese grupo) es
mínima. Cuanta menos variación tengamos dentro de los grupos, más homogéneos
(similares) serán los puntos de datos dentro del mismo grupo.

1.1. Funcionamiento y matemática detrás

La forma en que funciona el algoritmo k-means es la siguiente:
1. Especifica el número de clusters K.
2. Inicializa los centroides primero barajando el conjunto de datos y luego
seleccionando aleatoriamente K puntos de datos para los centroides sin
reemplazo.
3. Sigue iterando hasta que no haya cambios en los centroides. es decir, la
asignación de puntos de datos a grupos no está cambiando.

 Calcula la suma de la distancia al cuadrado entre los puntos de datos y todos los
centroides.
 Asigna a cada punto de datos al grupo más cercano (centroide).
 Calcula los centroides para los grupos tomando el promedio de todos los puntos
de datos que pertenecen a cada grupo.
El enfoque que kmeans sigue para resolver el problema se llama Expectación-
Maximización. El E-step es asignar los puntos de datos al grupo más cercano. El paso
M está calculando el centroide de cada grupo.
A continuación, se muestra un desglose de cómo podemos resolverlo
matemáticamente:
La función objetivo es:
donde wik = 1 para el punto de datos xi si pertenece al clúster k; de lo contrario, wik =
0. Además, μk es el centroide del grupo de xi.
Es un problema de minimización de dos partes. Primero minimizamos J w.r.t. wik y treat
μk fijo. Luego minimizamos J w.r.t. μk y tratar wik fijo. Técnicamente hablando,
diferenciamos a J w.r.t. wik primero y actualice las asignaciones de clúster (E-step).
Luego diferenciamos J w.r.t. μk y recalcule los centroides después de las asignaciones
de clúster del paso anterior (paso M). Por lo tanto, E-step es:

En otras palabras, asigne el punto de datos xi al grupo más cercano juzgado por su
suma de la distancia al cuadrado del centroide del grupo.
Y M-step es:

Lo que se traduce en volver a calcular el centroide de cada grupo para reflejar las
nuevas asignaciones.
Algunas cosas a tener en cuenta aquí:
 Dado que los algoritmos de agrupamiento que incluyen kmeans utilizan
mediciones basadas en la distancia para determinar la similitud entre los puntos
de datos, se recomienda estandarizar los datos para que tengan una media de
cero y una desviación estándar de uno, ya que casi siempre las características
en cualquier conjunto de datos tendrían diferentes unidades de medida como
edad vs ingresos.
  Dada la naturaleza iterativa de kmeans y la inicialización aleatoria de los
centroides al comienzo del algoritmo, las diferentes inicializaciones pueden dar
lugar a diferentes agrupaciones, ya que el algoritmo de kmeans puede atascarse
en un óptimo local y puede no converger al óptimo global. Por lo tanto, se
recomienda ejecutar el algoritmo utilizando diferentes inicializaciones de
centroides y elegir los resultados de la ejecución que produjeron la suma más
baja de la distancia al cuadrado.
 La asignación de ejemplos no está cambiando es lo mismo que no hay cambio
en la variación dentro del clúster:

1.2. Implementación
Aquí usaremos una implementación simple de kmeans para ilustrar algunos conceptos.
Luego, utilizaremos la implementación de sklearn que es más eficiente, nos
encargamos de muchas cosas.

impor
t
numpy
as np
from numpy.linalg import norm

class Kmeans:
'''Implementing Kmeans algorithm.'''

def __init__(self, n_clusters, max_iter=100, random_state=123):

self.n_clusters = n_clusters
self.max_iter = max_iter
self.random_state = random_state

def initializ_centroids(self, X):

np.random.RandomState(self.random_state)
random_idx = np.random.permutation(X.shape[0])
 centroids = X[random_idx[:self.n_clusters]]
return centroids

def compute_centroids(self, X, labels):

centroids = np.zeros((self.n_clusters, X.shape[1]))
for k in range(self.n_clusters):
centroids[k, :] = np.mean(X[labels == k, :], axis=0)
return centroids

def compute_distance(self, X, centroids):

distance = np.zeros((X.shape[0], self.n_clusters))
for k in range(self.n_clusters):
row_norm = norm(X - centroids[k, :], axis=1)
distance[:, k] = np.square(row_norm)
return distance

def find_closest_cluster(self, distance):

return np.argmin(distance, axis=1)

def compute_sse(self, X, labels, centroids):

distance = np.zeros(X.shape[0])
for k in range(self.n_clusters):
distance[labels == k] = norm(X[labels == k] - centroids[k],
axis=1)
return np.sum(np.square(distance))

def fit(self, X):

self.centroids = self.initializ_centroids(X)
for i in range(self.max_iter):
old_centroids = self.centroids
distance = self.compute_distance(X, old_centroids)
self.labels = self.find_closest_cluster(distance)
self.centroids = self.compute_centroids(X, self.labels)
if np.all(old_centroids == self.centroids):
break
self.error = self.compute_sse(X, self.labels, self.centroids)

def predict(self, X):

distance = self.compute_distance(X, old_centroids)
 return self.find_closest_cluster(distance)

1.3. Aplicaciones
El algoritmo kmeans es muy popular y se utiliza en una variedad de aplicaciones, como
la segmentación del mercado, la agrupación de documentos, la segmentación de
imágenes y la compresión de imágenes, etc. El objetivo generalmente cuando nos
sometemos a un análisis de conglomerados es:
 Obtener una intuición significativa de la estructura de los datos con los que
estamos tratando.
 Agrupar y luego predecur dónde se construirán diferentes modelos para
diferentes subgrupos si creemos que existe una amplia variación en los
comportamientos de diferentes subgrupos. Un ejemplo de esto es agrupar a los
pacientes en diferentes subgrupos y construir un modelo para cada subgrupo
para predecir la probabilidad del riesgo de sufrir un ataque cardíaco.

1.4. Parámetros
n_clustersint, por defecto = 8
El número de grupos para formar, así como el número de centroides para generar.

init {‘k-means ++’, ‘random’} o ndarray of shape (n_clusters, n_features), default =

’k-means ++’
Método de inicialización, el valor predeterminado es "k-means ++":
"K-means ++": selecciona los centros de agrupación iniciales para la agrupación de k-
mean de una manera inteligente para acelerar la convergencia. Vea la sección Notas
en k_init para más detalles.
"Aleatorio": elija k observaciones (filas) al azar de los datos para los centroides
iniciales.
Si se pasa un ndarray, debe tener forma (n_clusters, n_features) y da los centros
iniciales.

n_initint, por defecto = 10

Número de veces que el algoritmo k-means se ejecutará con diferentes semillas
centroides. Los resultados finales serán la mejor salida de n_init ejecuciones
consecutivas en términos de inercia.
max_iterint, por defecto = 300
Número máximo de iteraciones del algoritmo k-means para una sola ejecución.

tolfloat, por defecto = 1e-4

Tolerancia relativa con respecto a la inercia para declarar convergencia.

precompute_distances‘auto ’o bool, default =’ auto ’

Precalcule las distancias (más rápido pero requiere más memoria).
"Auto": no precalcule distancias si n_muestras * n_grupos> 12 millones. Esto
corresponde a unos 100 MB de sobrecarga por trabajo con doble precisión.
Cierto: siempre precalcule las distancias.
Falso: nunca precalcule distancias.

verboseint, default = 0
Modo de verbosidad.

random_stateint, instancia RandomState, predeterminado = Ninguno

Determina la generación de números aleatorios para la inicialización del centroide. Use
un int para hacer que la aleatoriedad sea determinista. Ver glosario.

copy_xbool, default = True

Cuando se calculan previamente las distancias, es más preciso numéricamente centrar
primero los datos. Si copy_x es True (predeterminado), los datos originales no se
modifican, lo que garantiza que X sea contiguo en C. Si es falso, los datos originales se
modifican y se vuelven a colocar antes de que regrese la función, pero se pueden
introducir pequeñas diferencias numéricas restando y luego sumando la media de los
datos, en este caso tampoco garantizará que los datos sean contiguos en C, lo que
puede causar Una desaceleración significativa.

n_jobsint: int = Ninguno

El número de trabajos a utilizar para el cálculo. Esto funciona calculando cada una de
las n_init se ejecuta en paralelo.
Ninguno significa 1 a menos que se encuentre en un contexto joblib.parallel_backend.
-1 significa usar todos los procesadores. Ver Glosario para más detalles.

Algorithm : {"auto", "full", "elkan"}, default = "auto"

Algoritmo K-means a utilizar. El algoritmo clásico de estilo EM es "completo". La

variación "elkan" es más eficiente mediante el uso de la desigualdad del triángulo, pero
actualmente no admite datos escasos. "Auto" elige "elkan" para datos densos y
"completo" para datos dispersos.

1.5. Ejemplo K-means segmentación de erupciones

Primero implementaremos el algoritmo kmeans en el conjunto de datos 2D y veremos
cómo funciona. El conjunto de datos tiene 272 observaciones y 2 características. Los
datos cubren el tiempo de espera entre erupciones y la duración de la erupción para el
géiser Old Faithful en el Parque Nacional de Yellowstone, Wyoming, EE. UU.
Intentaremos encontrar K subgrupos dentro de los puntos de datos y agruparlos en
consecuencia. A continuación, se muestra la descripción de las características:
erupciones (float): tiempo de erupción en minutos.
waiting (int): tiempo de espera hasta la próxima erupción.

Tracemos primero los datos:

Utilizaremos estos datos porque es fácil de trazar y detectar visualmente los clústeres
ya que es un conjunto de datos de 2 dimensiones. Es obvio que tenemos 2 grupos.
Primero estandaricemos los datos y ejecutemos el algoritmo kmeans en los datos
estandarizados con K = 2.
El gráfico anterior muestra el diagrama de dispersión de los datos coloreados por el
grupo al que pertenecen. En este ejemplo, elegimos K = 2. El símbolo ‘*‘ es el centroide
de cada grupo. Podemos pensar en esos 2 grupos como géiseres que tenían diferentes
tipos de comportamientos en diferentes escenarios.
A continuación, mostraremos que diferentes inicializaciones de centroides pueden dar
lugar a resultados diferentes. Usaré 9 estados aleatorios diferentes para cambiar la
inicialización de los centroides y trazar los resultados. El título de cada parcela será la
suma de la distancia al cuadrado de cada inicialización.
Como nota al margen, este conjunto de datos se considera muy fácil y converge en
menos de 10 iteraciones. Por lo tanto, para ver el efecto de la inicialización aleatoria en
la convergencia, voy a ir con 3 iteraciones para ilustrar el concepto. Sin embargo, en
las aplicaciones del mundo real, los conjuntos de datos no son tan limpios y
agradables.
Como el gráfico anterior muestra que solo terminamos con dos formas diferentes de
agrupaciones basadas en diferentes inicializaciones. Escogeríamos el que tenga la
menor suma de distancia al cuadrado.
 2. Afinity Propagation
AffinityPropagation crea grupos enviando mensajes entre pares de muestras hasta la
convergencia. Luego se describe un conjunto de datos utilizando un pequeño número
de ejemplos, que se identifican como los más representativos de otras muestras. Los
mensajes enviados entre pares representan la idoneidad para que una muestra sea el
ejemplo de la otra, que se actualiza en respuesta a los valores de otros pares. Esta
actualización ocurre iterativamente hasta la convergencia, en cuyo punto se eligen los
ejemplos finales y, por lo tanto, se proporciona la agrupación final.

2.1. Funcionamiento y matemática detrás

AP toma como entrada las similitudes entre los puntos de datos e identifica ejemplos
basados en ciertos criterios. Los mensajes se intercambian entre los puntos de datos
hasta que se obtiene un conjunto de ejemplos de alta calidad.
intentemos comprender este algoritmo con la ayuda de un ejemplo. Tenemos
información sobre las preferencias de cinco participantes.

Necesitamos calcular las siguientes matrices:

 Matriz de similitud
 Matriz de responsabilidad
 Matriz de disponibilidad
 Matriz de criterios
Vamos a entender lo que significan estas matrices en un momento.
 2.1.1. Matriz de similitud:
La matriz de similitud (S) nos brinda información sobre la similitud entre cualquier
instancia, en nuestro caso entre dos personas.
S (i, j) = - || xi-xj || ²
La similitud, en nuestro caso, se define como la negativa de la distancia euclidiana
entre las dos instancias. Cuanto mayor es la distancia entre dos instancias, menor es la
similitud entre ellas.
Entonces obtenemos una matriz de similitud de la siguiente manera:

Los valores de los elementos fuera de la diagonal dictarán el número de grupos

formados. Cuanto menor es el valor (valor≤0), menor es el número de grupos
obtenidos.
Intuición: ¿Por qué?
Veamos casos extremos donde (valor = 0) o (valor = min (sim (i, j))).
Para un elemento i buscamos otro elemento j para el cual sim (i, j) es el más alto.
Establecer los valores diagonales para que sea igual a cero devolvería el mismo
elemento i. Como cada elemento se mapearía consigo mismo, se obtendría más
cantidad de clústeres.
Mientras que, cuando el valor diagonal se establece igual a min (sim (i, j)), para un
elemento i, se encontrará un elemento j, tal que i ≠ j. Otro elemento k también podría
mapearse con el elemento j. Si esto sucede, entonces i, j, k se considerarían muy
similares y podrían agruparse.
En nuestro caso, estableceremos el valor de los elementos diagonales para que sea
igual a min (sim (i, j)), es decir, -22. También se puede configurar este valor para que
sea igual a la mediana de todas las similitudes.
 2.1.2. Matriz de responsabilidad:
La responsabilidad r (i, k) cuantifica cuán bien adaptado es el elemento k, para ser un
ejemplo para el elemento i, teniendo en cuenta que el contendiente más cercano k 'es
un ejemplo para i.

Inicializamos la matriz R con ceros.

La intuición detrás de la fórmula:
r (i, k) puede considerarse como una similitud relativa entre i y k. Cuantifica cuán similar
es ik, en comparación con algunas k ', teniendo en cuenta la disponibilidad de k'. La
responsabilidad de k hacia i disminuirá a medida que aumente la disponibilidad de otros
k 'a i.

2.1.3. Matriz de disponibilidad:

La disponibilidad a (i, k) cuantifica qué tan apropiado es que i elija k como su ejemplar,
teniendo en cuenta el apoyo de otros elementos que k debería ser un ejemplar.

Intuición detrás de la fórmula:

La disponibilidad es responsabilidad propia de k más las responsabilidades positivas de
k hacia elementos distintos de i. Incluimos solo responsabilidades positivas, ya que un
ejemplar debe ser positivamente responsable / explicar al menos bien algunos puntos
de datos, independientemente de qué tan mal explique otros puntos de datos.
Si la responsabilidad propia es negativa, significa que k es más adecuado para
pertenecer a otro ejemplar, en lugar de ser un ejemplar. El valor máximo de a (i, k) es
0.
Las disponibilidades propias se calculan de la siguiente manera:
a (k, k) refleja la evidencia acumulada de que el punto k es adecuado para ser un
ejemplo, basado en las responsabilidades positivas de k hacia otros elementos.
Las matrices R y A se actualizan iterativamente. Este procedimiento puede finalizar
después de un número fijo de iteraciones, después de que los cambios en los valores
obtenidos caigan por debajo de un umbral, o después de que los valores permanezcan
constantes durante cierto número de iteraciones.
En nuestro caso, se realizaron actualizaciones hasta que los valores se mantuvieron
constantes y se obtuvieron las siguientes matrices R y A.
 2.1.4. Matriz de criterios

La matriz de criterios se calcula después de que finaliza la actualización. La matriz de

criterios C es la suma de R y A. Un elemento i se asignará a un ejemplar k que no solo
es altamente responsable sino también altamente disponible para i.

El elemento con el valor de criterio más alto en cada fila se designaría como un
ejemplo. Los elementos correspondientes a las filas que comparten el mismo ejemplar
se agrupan.
En nuestro caso, Alice, Bob, Cary pertenecen a un grupo y Doug y Edna a otro.
Nota: Dado que se utiliza una métrica de distancia para calcular las similitudes, se
recomienda estandarizar los parámetros antes de la agrupación utilizando Propagación
de afinidad.
 2.2. Aplicación
Los inventores de affinity propagation demostraron que es mejor para ciertas tareas de
visión por computadora y biología computacional, p. agrupamiento de imágenes de
rostros humanos e identificación de transcripciones reguladas, que k-means, incluso
cuando k-means se permitió muchos reinicios aleatorios e inicializados utilizando PCA.
Un estudio que comparó la propagación de afinidad y la agrupación de Markov en la
partición del gráfico de interacción de proteínas encontró que la agrupación de Markov
funciona mejor para ese problema. Se ha propuesto una variante semi-supervisada
para aplicaciones de minería de texto.

2.3. Parámetros
dampingfloat, predeterminado = 0.5
El factor de amortiguamiento (entre 0.5 y 1) es el grado en que el valor actual se
mantiene en relación con los valores entrantes (ponderado 1 - amortiguamiento). Esto
para evitar oscilaciones numéricas al actualizar estos valores (mensajes).

max_iterint, por defecto = 200

Número máximo de iteraciones.

convergence_iterint, default = 15
Número de iteraciones sin cambios en el número de clústeres estimados que detiene la
convergencia.

copybool, default = True

Haga una copia de los datos de entrada.

preferencearray-like of shape (n_samples,) o flotante, por defecto = Ninguno

Preferencias para cada punto: es más probable que los puntos con valores más
grandes de preferencias sean elegidos como ejemplos. El número de ejemplos, es
decir, de grupos, está influenciado por el valor de las preferencias de entrada. Si las
preferencias no se pasan como argumentos, se establecerán en la mediana de las
similitudes de entrada.
affinity {"euclidiana", "precalculada", predeterminada = "euclidiana"
Qué afinidad usar. Por el momento, "precalculado" y euclidiano son compatibles.
"Euclidiana" utiliza la distancia euclidiana al cuadrado negativa entre puntos.

verbosebool, default = False

Ya sea para ser detallado.

2.4. Ejemplo con código

import numpy as np
from matplotlib import pyplot as plt
import seaborn as sns
sns.set()
from sklearn.datasets.samples_generator import make_blobs
from sklearn.cluster import AffinityPropagation

X, clusters = make_blobs(n_samples=300, centers=4, cluster_std=0.60,

random_state=0)
plt.scatter(X[:,0], X[:,1], alpha=0.7, edgecolors='b')

af = AffinityPropagation(preference=-50)clustering = af.fit(X)
plt.scatter(X[:,0], X[:,1], c=clustering.labels_, cmap='rainbow',
alpha=0.7, edgecolors='b')

3. Mean Shift
Mean Shift es un algoritmo de agrupamiento jerárquico. A diferencia de los algoritmos
supervisados de aprendizaje automático, la agrupación intenta agrupar los datos sin
haber sido entrenados primero en los datos etiquetados. La agrupación se utiliza en
una amplia variedad de aplicaciones, como motores de búsqueda, rankings
académicos y medicina. A diferencia de los K-Means, cuando se usa Mean Shift, no
necesita saber de antemano el número de categorías (grupos). La desventaja de Mean
Shift es que es computacionalmente costoso: O (n²).

3.1. Funcionamiento y matemática detrás

Dado un candidato centroide para la iteración, el candidato se actualiza de acuerdo con

la siguiente ecuación:

x ti +1=m( x ti )
Dónde N(xi) es el vecindario de muestras dentro de una distancia dada alrededor de xi
y m es el vector de desplazamiento medio que se calcula para cada centroide que
apunta hacia una región del aumento máximo en la densidad de puntos. Esto se
calcula utilizando la siguiente ecuación, actualizando efectivamente un centroide para
que sea la media de las muestras dentro de su vecindad:

∑ ❑ K ( x j−x i) x j
x j ∈ N( xi )
m(x i)=
∑ ❑ K ( x j−x i )
x j ∈ N (x i )

El algoritmo establece automáticamente el número de clústeres, en lugar de depender

de un ancho de banda de parámetro, que dicta el tamaño de la región para buscar.
Este parámetro puede establecerse manualmente, pero puede estimarse utilizando la
función de estimación de ancho de banda proporcionada, que se llama si no se
establece el ancho de banda.

PASO 1: Elija cualquier punto aleatorio y coloque la ventana en ese punto de datos.
PASO 2: Calcule la media de todos los puntos que se encuentran dentro de esta ventana.

PASO 3: Cambie la ventana, de modo que se encuentre en la ubicación de la media.

 PASO 4: Repita hasta la convergencia.

3.2. Aplicación

Agrupación
Considere un conjunto de puntos en un espacio bidimensional. Suponga una ventana
circular centrada en C y que tenga un radio r como núcleo. El cambio medio es un
algoritmo de escalada que implica cambiar este núcleo iterativamente a una región de
mayor densidad hasta la convergencia. Cada cambio está definido por un vector de
cambio medio. El vector de desplazamiento medio siempre apunta hacia la dirección
del aumento máximo de la densidad. En cada iteración, el núcleo se desplaza al
centroide o la media de los puntos dentro de él. El método para calcular esta media
depende de la elección del núcleo. En este caso, si se elige un núcleo gaussiano en
lugar de un núcleo plano, a cada punto se le asignará primero un peso que decaerá
exponencialmente a medida que aumente la distancia desde el centro del núcleo. En la
convergencia, no habrá una dirección en la que un cambio pueda acomodar más
puntos dentro del núcleo.

Rastreo
El algoritmo de cambio medio se puede usar para el seguimiento visual. El algoritmo
más simple de este tipo crearía un mapa de confianza en la nueva imagen basado en
el histograma de color del objeto en la imagen anterior, y usaría el desplazamiento
medio para encontrar el pico de un mapa de confianza cerca de la posición anterior del
objeto. El mapa de confianza es una función de densidad de probabilidad en la nueva
imagen, asignando una probabilidad a cada píxel de la nueva imagen, que es la
probabilidad de que ocurra el color del píxel en el objeto de la imagen anterior.

3.3. Parámetros

Bandwidthfloat: optional
Ancho de banda utilizado en el núcleo RBF.
Si no se proporciona, el ancho de banda se estima utilizando
sklearn.cluster.estimate_bandwidth; Consulte la documentación de esa función para
obtener sugerencias sobre la escalabilidad (consulte también las Notas a continuación).

seedsarray, shape=[n_samples, n_features], optional

Semillas utilizadas para inicializar granos. Si no se establece, las semillas se calculan
agrupando.get_bin_seeds con ancho de banda como el tamaño de la cuadrícula y los
valores predeterminados para otros parámetros.

bin_seedingboolean, opcional
Si es verdadero, las ubicaciones iniciales del núcleo no son ubicaciones de todos los
puntos, sino más bien la ubicación de la versión discretizada de puntos, donde los
puntos se agrupan en una cuadrícula cuyo grosor corresponde al ancho de banda.
Establecer esta opción en Verdadero acelerará el algoritmo porque se inicializarán
menos semillas. valor predeterminado: Falso Ignorado si el argumento de semillas no
es Ninguno.

min_bin_freqint: opcional
Para acelerar el algoritmo, acepte solo aquellos contenedores con al menos
min_bin_freq puntos como semillas. Si no está definido, establezca en 1.

cluster_allboolean: predeterminado True

Si es verdadero, entonces todos los puntos están agrupados, incluso aquellos
huérfanos que no están dentro de ningún núcleo. Los huérfanos se asignan al núcleo
más cercano. Si es falso, los huérfanos reciben la etiqueta de grupo -1.
n_jobsint o None, opcional (predeterminado = Ninguno)
El número de trabajos a utilizar para el cálculo. Esto funciona calculando cada una de
las n_init se ejecuta en paralelo.
Ninguno significa 1 a menos que se encuentre en un contexto joblib.parallel_backend.
-1 significa usar todos los procesadores. Ver Glosario para más detalles.

max_iterint, por defecto = 300

Número máximo de iteraciones, por punto inicial antes de que finalice la operación de
agrupación (para ese punto inicial), si aún no ha convergido.

3.4. Ejemplo de aplicación: segmentación de imágenes

Una buena aplicación visual del cambio medio es la segmentación de imágenes. El

objetivo general de la segmentación de imágenes es dividir una imagen en regiones
semánticamente significativas. Esto se puede lograr agrupando los píxeles en la
imagen. Considere la siguiente foto que tomé recientemente (en gran parte porque la
agradable variación de color lo convierte en una buena imagen de ejemplo para la
segmentación de imágenes).
El primer paso es representar esta imagen como puntos en un espacio. Hay varias
formas de hacer esto, pero una manera fácil es mapear cada píxel a un punto en un
espacio RGB tridimensional utilizando sus valores de píxel rojo, verde y azul. Hacerlo
para la imagen de arriba da como resultado el siguiente conjunto de puntos.

Entonces podemos ejecutar el cambio medio en los puntos anteriores. La siguiente

animación muestra cómo cambia cada punto a medida que se ejecuta el algoritmo,
utilizando un núcleo gaussiano con un valor de ancho de banda del núcleo de 25.
Tenga en cuenta que agrupé la versión reducida de la imagen (160 × 120) para permitir
que se ejecute en un período de tiempo razonable.

Cada punto (p. Ej., Píxel) eventualmente cambió a uno de los siete modos (p. Ej., Picos
de superficie de KDE). Mostrar la imagen usando el color de estos siete modos produce
lo siguiente.
 4. Spectral clustering
SpectralClustering realiza una incrustación de baja dimensión de la matriz de afinidad
entre las muestras, seguida de la agrupación, por ejemplo, por KMeans, de los
componentes de los vectores propios en el espacio de baja dimensión. Es
especialmente eficiente desde el punto de vista computacional si la matriz de afinidad
es escasa y el solucionador de amg se usa para el problema del valor propio (tenga en
cuenta que el solucionador de amg requiere que el módulo pyamg esté instalado).

4.1. Funcionamiento y matemática detrás

Para realizar una agrupación espectral necesitamos 3 pasos principales:

 Crear un gráfico de similitud entre nuestros N objetos para agrupar.
 Calcular los primeros k vectores propios de su matriz laplaciana para definir un
vector de características para cada objeto.
 Ejecutar k-means en estas características para separar objetos en k clases.

Paso 1:
Una buena manera de representar un conjunto de puntos de datos x1,. . . x N tiene la
forma del gráfico de similitud G = (V, E).
Hay diferentes formas de construir un gráfico que represente las relaciones entre los
puntos de datos:
1. Gráfico de vecindad ε: cada vértice está conectado a vértices que caen dentro
de una bola de radio ε donde ε es un valor real que debe ajustarse para captar la
estructura local de datos.
2. Gráfico de vecino más cercano a k: cada vértice está conectado a sus vecinos
más cercanos a k donde k es un número entero que controla las relaciones
locales de datos.

En el ejemplo anterior dibujamos 3 grupos: dos "lunas" y una gaussiana.

En el gráfico de ε-vecindad, podemos ver que es difícil elegir un parámetro útil ε. Con ε
= 0.3 como en la figura, los puntos en la luna media ya están muy estrechamente
conectados, mientras que los puntos en el Gaussiano están apenas conectados. Este
problema siempre ocurre si tenemos datos "en diferentes escalas", es decir, las
distancias entre los puntos de datos son diferentes en diferentes regiones del espacio.
Sin embargo, el gráfico vecino k-más cercano, puede conectar puntos "en diferentes
escalas". Podemos ver que los puntos en el gaussiano de baja densidad están
conectados con puntos en la luna de alta densidad.

Paso 2:
Ahora que tenemos nuestro gráfico, necesitamos formar su matriz laplaciana asociada.
N.B .: Las herramientas principales para la agrupación espectral son las matrices
laplacianas gráficas.

Todo lo que tenemos que hacer ahora es calcular los vectores propios u_ j de L.

Paso 3:
Ejecutar k-means:
 4.2. Aplicación
La agrupación espectral tiene muchas aplicaciones en aprendizaje automático, análisis exploratorio de
datos, computadora Visión y procesamiento del habla. La mayoría de las técnicas asumen de manera
explícita o implícita una estructura métrica o de similitud en el espacio de configuraciones, que luego
utilizan los algoritmos de agrupamiento. El éxito de tales algoritmos depende en gran medida de la
elección de la métrica, pero esta elección es generalmente no tratada como parte del problema de
aprendizaje. Por lo tanto, la selección manual de funciones y el tiempo

4.3. Parámetros

n_clustersinteger, opcional
La dimensión del subespacio de proyección.

eigen_solver {Ninguno, ‘arpack’, ‘lobpcg’ o ‘amg’}

La estrategia de descomposición del valor propio a utilizar. AMG requiere la instalación
de pyamg. Puede ser más rápido en problemas muy grandes y escasos, pero también
puede provocar inestabilidades.

n_componentsinteger, opcional, por defecto = n_clusters

Número de vectores propios a utilizar para la inclusión espectral

random_stateint, RandomState instancia o None (predeterminado)

Un generador de números pseudoaleatorios utilizado para la inicialización de la
descomposición de vectores propios lobpcg cuando eigen_solver = 'amg' y por la
inicialización K-Means. Use un int para hacer que la aleatoriedad sea determinista. Ver
glosario.

n_initint, opcional, predeterminado: 10

Número de veces que el algoritmo k-means se ejecutará con diferentes semillas
centroides. Los resultados finales serán la mejor salida de n_init ejecuciones
consecutivas en términos de inercia.

gammafloat, por defecto = 1.0

Coeficiente de kernel para rbf, poli, sigmoide, laplaciano y chi2. Ignorado por afinidad =
'vecino_más cercano'.

cadena de afinidad o invocable, predeterminado 'rbf'

Cómo construir la matriz de afinidad.
"Vecinos_más cercanos": construya la matriz de afinidad calculando un gráfico de los
vecinos más cercanos.
"Rbf": construye la matriz de afinidad usando un núcleo de función de base radial
(RBF).
"Precalculado": interpreta X como una matriz de afinidad calculada previamente.
"Precomputed_nearest_neighours": interpreta X como un gráfico escaso de vecinos
más cercanos calculados previamente y construye la matriz de afinidad seleccionando
los vecinos más cercanos.
uno de los núcleos soportados por pairwise_kernels.
Solo se deben usar granos que producen puntajes de similitud (valores no negativos
que aumentan con la similitud). El algoritmo de agrupamiento no verifica esta
propiedad.

n_neighboursinteger
Número de vecinos a utilizar al construir la matriz de afinidad utilizando el método de
vecinos más cercanos. Ignorado por afinidad = 'rbf'.

eigen_tolfloat, opcional, predeterminado: 0.0

Criterio de detención para la descomposición propia de la matriz laplaciana cuando
eigen_solver = 'arpack'.

asignar_etiquetas {‘kmeans’, ‘discretize’}, predeterminado: ‘kmeans’

La estrategia a utilizar para asignar etiquetas en el espacio de incrustación. Hay dos
formas de asignar etiquetas después de la incrustación laplaciana. k-means se puede
aplicar y es una opción popular. Pero también puede ser sensible a la inicialización. La
discretización es otro enfoque que es menos sensible a la inicialización aleatoria.
degreefloat, predeterminado = 3
Grado del núcleo polinomial. Ignorado por otros núcleos.

coef0float, por defecto = 1

Coeficiente cero para núcleos polinomiales y sigmoides. Ignorado por otros núcleos.

kernel_paramsdictionary de cadena a cualquiera, opcional

Parámetros (argumentos de palabras clave) y valores para kernel pasados como objeto
invocable. Ignorado por otros núcleos.

n_jobsint o None, opcional (predeterminado = Ninguno)

El número de trabajos paralelos a ejecutar. Ninguno significa 1 a menos que se
encuentre en un contexto joblib.parallel_backend. -1 significa usar todos los
procesadores. Ver Glosario para más detalles.

4.4. Implementación

Paso 1: Importar las bibliotecas requeridas

import pandas as pd
import matplotlib.pyplot as plt
from sklearn.cluster import SpectralClustering
from sklearn.preprocessing import StandardScaler, normalize
from sklearn.decomposition import PCA
from sklearn.metrics import silhouette_score

Paso 2: carga y limpieza de los datos

# Changing the working location to the location of the data
cd "C:\Users\Dev\Desktop\Kaggle\Credit_Card"
  
# Loading the data
X = pd.read_csv('CC_GENERAL.csv')
  
# Dropping the CUST_ID column from the data
X = X.drop('CUST_ID', axis = 1)
  
# Handling the missing values if any
X.fillna(method ='ffill', inplace = True)
  
X.head()

Paso 3: preprocese los datos para hacerlos visibles

# Preprocessing the data to make it visualizable
  
# Scaling the Data
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
  
# Normalizing the Data
X_normalized = normalize(X_scaled)
  
# Converting the numpy array into a pandas DataFrame
X_normalized = pd.DataFrame(X_normalized)
  
# Reducing the dimensions of the data
pca = PCA(n_components = 2)
X_principal = pca.fit_transform(X_normalized)
X_principal = pd.DataFrame(X_principal)
X_principal.columns = ['P1', 'P2']
  
X_principal.head()

Paso 4: crear los modelos de agrupación y visualizar la agrupación

En los pasos a continuación, dos modelos de agrupación espectral diferentes con
valores diferentes para el parámetro "afinidad". Puede leer sobre la documentación de
la clase de agrupación espectral aquí.
a) afinidad = "rbf"
# Building the clustering model
spectral_model_rbf = SpectralClustering(n_clusters = 2, affinity ='rbf')
  
# Training the model and Storing the predicted cluster labels
labels_rbf = spectral_model_rbf.fit_predict(X_principal)

# Building the label to colour mapping

colours = {}
colours[0] = 'b'
colours[1] = 'y'
  
# Building the colour vector for each data point
cvec = [colours[label] for label in labels_rbf]
  
# Plotting the clustered scatter plot
  
b = plt.scatter(X_principal['P1'], X_principal['P2'], color ='b');
y = plt.scatter(X_principal['P1'], X_principal['P2'], color ='y');
  
plt.figure(figsize =(9, 9))
plt.scatter(X_principal['P1'], X_principal['P2'], c = cvec)
plt.legend((b, y), ('Label 0', 'Label 1'))
plt.show()
b) affinity = ‘nearest_neighbors’
# Building the clustering model
spectral_model_nn = SpectralClustering(n_clusters = 2, affinity
='nearest_neighbors')
  
# Training the model and Storing the predicted cluster labels
labels_nn = spectral_model_nn.fit_predict(X_principal)

Paso 5: evaluación del rendimiento

# List of different values of affinity
affinity = ['rbf', 'nearest-neighbours']
  
# List of Silhouette Scores
s_scores = []
  
# Evaluating the performance
s_scores.append(silhouette_score(X, labels_rbf))
s_scores.append(silhouette_score(X, labels_nn))
  
print(s_scores)

Paso 6: comparando el rendimiento

# Plotting a Bar Graph to compare the models
plt.bar(affinity, s_scores)
plt.xlabel('Affinity')
plt.ylabel('Silhouette Score')
plt.title('Comparison of different Clustering Models')
plt.show()
 5. OPTICS
Ordenar puntos para identificar la estructura de agrupamiento (OPTICS) es un
algoritmo para encontrar grupos basados en densidad en datos espaciales. Fue
presentado por Mihael Ankerst, Markus M. Breunig, Hans-Peter Kriegel y Jörg Sander.
Su idea básica es similar a DBSCAN, pero aborda una de las principales debilidades de
DBSCAN: el problema de detectar grupos significativos en datos de densidad variable.
Para hacerlo, los puntos de la base de datos se ordenan (linealmente) de modo que los
puntos espacialmente más cercanos se conviertan en vecinos en el orden. Además, se
almacena una distancia especial para cada punto que representa la densidad que se
debe aceptar para un grupo para que ambos puntos pertenezcan al mismo grupo. Esto
se representa como un dendrograma.

5.1. Funcionamiento y matemática detrás

Para comprender cómo crea esta trama, debe comprender algunas definiciones.
Primero debe comprender cómo funciona DBSCAN, los parámetros que utiliza y la
diferencia entre los puntos centrales y los límites. También agregaremos un par de
definiciones más
Distancia del núcleo: el épsilon mínimo para convertir un punto distinto en un punto
central, dado un parámetro MinPts finito.
Distancia de accesibilidad: la distancia de accesibilidad de un objeto p con respecto a
otro objeto o es la distancia más pequeña desde o si o es un objeto central. Tampoco
puede ser menor que la distancia del núcleo de o.
Aunque el parámetro MinPts se usa en estos cálculos, la idea es que no tendría un
gran impacto porque todas las distancias se escalarían aproximadamente a la misma
velocidad.
El siguiente paso será extraer las etiquetas de clúster reales del gráfico. La forma más
común de hacerlo es buscando "valles" en la trama, utilizando mínimos y máximos
locales. Aquí podrían entrar en juego algunos parámetros más, dependiendo del
método utilizado.
Vea a continuación una comparación de algunos datos de muestra generados y las
etiquetas ópticas resultantes y el gráfico de accesibilidad. Los puntos coloreados son
aquellos identificados como grupos, mientras que los grises representan ruido.
Observe que hay una buena cantidad de puntos identificados como puntos de ruido en
este ejemplo generado. Tienen densidades similares a las del grupo amarillo, pero no
se reconocen en esta extracción porque se enfoca en separar las regiones más
densas. Aquí es donde el ajuste fino de los parámetros de extracción se beneficiaría.
Otros métodos de extracción de grupos también podrían utilizarse en este caso.

5.2. Aplicación

Detección de valores atípicos

Otro aspecto interesante del algoritmo OPTICS es una extensión que se utiliza para la
detección de valores atípicos, llamada OPTICS-OF (OF for Outlier Factor). Esto le dará
un puntaje atípico a cada punto, es decir, una comparación con sus vecinos más
cercanos en lugar de con todo el conjunto. Este es un tipo único de detección de
valores atípicos debido a este principio "local". También podemos usar algunos de los
cálculos anteriores mientras lo creamos.
Primero, lo que hace es crear una nueva medida, "densidad de accesibilidad local", que
es la inversa de la accesibilidad promedio (con respecto al punto que está calculando)
de los vecinos MinPts.

Una vez que hayamos hecho esto para cada punto, calcularemos el Factor Outlier.
Para hacerlo, tome el promedio de las relaciones de los MinPts-vecinos a ese punto
específico, como se muestra a continuación.

El componente "local" de OPTICS-OF es clave para lo que lo separa de otros métodos

de detección atípicos, ya que trata de explicar la vecindad de la opción específica.
También es capaz de darle un puntaje de valor atípico relativo, en lugar de solo un
valor binario. Se muestra un ejemplo del proyecto que se analiza a continuación, con
los objetos atípicos en rojo, tomando un límite del factor atípico en 2.
Una desventaja de la detección OPTICS-OF es que no puede manejar bien los
duplicados. Si suficientes puntos ocupan el mismo espacio, pueden tener una distancia
de capacidad de alcance de 0, lo que causa problemas en nuestros cálculos de
factores atípicos locales. En este escenario, simplemente eliminé todos los duplicados.
 5.3. OPTICS VS DBSCAN

Costo de memoria: la técnica de agrupación OPTICS requiere más memoria, ya que

mantiene una cola de prioridad (Min Heap) para determinar el siguiente punto de datos
que está más cerca del punto que se procesa actualmente en términos de Distancia de
accesibilidad. También requiere más potencia computacional porque las consultas
vecinas más cercanas son más complicadas que las consultas de radio en DBSCAN.
Menos parámetros: la técnica de agrupación OPTICS no necesita mantener el
parámetro epsilon y solo se proporciona en el pseudocódigo anterior para reducir el
tiempo necesario. Esto conduce a la reducción del proceso analítico de ajuste de
parámetros.
Esta técnica no segrega los datos dados en grupos. Simplemente produce un gráfico
de distancia de accesibilidad y es sobre la interpretación del programador agrupar los
puntos en consecuencia.

5.4. Parámetros
min_samplesint> 1 o flotante entre 0 y 1 (predeterminado = 5)
El número de muestras en un vecindario para que un punto sea considerado como un
punto central. Además, las regiones empinadas hacia arriba y hacia abajo no pueden
tener más de min_samples puntos no empinados consecutivos. Expresado como un
número absoluto o una fracción del número de muestras (redondeado para ser al
menos 2).

max_epsfloat, opcional (predeterminado = np.inf)

La distancia máxima entre dos muestras para que una se considere en la vecindad de
la otra. El valor predeterminado de np.inf identificará los clústeres en todas las escalas;
reducir max_eps dará como resultado tiempos de ejecución más cortos.

metricstr o invocable, opcional (predeterminado = "minkowski")

Métrica para usar para el cálculo de distancia. Se puede usar cualquier métrica de
scikit-learn o scipy.spatial.distance.
Si métrica es una función invocable, se llama en cada par de instancias (filas) y se
registra el valor resultante. El invocable debe tomar dos matrices como entrada y
devolver un valor que indica la distancia entre ellas. Esto funciona para las métricas de
Scipy, pero es menos eficiente que pasar el nombre de la métrica como una cadena. Si
la métrica está "calculada previamente", se supone que X es una matriz de distancia y
debe ser cuadrada.

Los valores válidos para la métrica son:

de scikit-learn: [‘cityblock’, ‘cosine’, ‘euclidean’, ‘l1’, ‘l2’, ‘manhattan’]
from scipy.spatial.distance: ['braycurtis', 'canberra', 'chebyshev', 'correlation', 'dice',
'hamming', 'jaccard', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto ',' russellrao
',' seuclidean ',' sokalmichener ',' sokalsneath ',' sqeuclidean ',' yule ']

pinta, opcional (por defecto = 2)

Parámetro para la métrica de Minkowski de sklearn.metrics.pairwise_distances.
Cuando p = 1, esto es equivalente a usar manhattan_distance (l1) y euclidean_distance
(l2) para p = 2. Para p arbitrario, se usa minkowski_distance (l_p).

metric_paramsdict, opcional (predeterminado = Ninguno)

Argumentos de palabras clave adicionales para la función métrica.

cluster_methodstr, opcional (predeterminado = 'xi')

El método de extracción utilizado para extraer clusters utilizando la accesibilidad y el
orden calculados. Los valores posibles son "xi" y "dbscan".

epsfloat, opcional (predeterminado = Ninguno)

La distancia máxima entre dos muestras para que una se considere en la vecindad de
la otra. Por defecto, asume el mismo valor que max_eps. Se usa solo cuando
cluster_method = 'dbscan'.

xifloat, entre 0 y 1, opcional (por defecto = 0.05)

Determina la inclinación mínima en el gráfico de accesibilidad que constituye un límite
de grupo. Por ejemplo, un punto ascendente en el gráfico de accesibilidad se define por
la relación entre un punto y su sucesor como máximo 1-xi. Se usa solo cuando
cluster_method = 'xi'.
predecessor_correctionbool, opcional (predeterminado = True)
Clústeres correctos según los predecesores calculados por OPTICS [R2c55e37003fe-
2]. Este parámetro tiene un efecto mínimo en la mayoría de los conjuntos de datos. Se
usa solo cuando cluster_method = 'xi'.

min_cluster_sizeint> 1 o flotante entre 0 y 1 (predeterminado = Ninguno)

Número mínimo de muestras en un grupo OPTICS, expresado como un número
absoluto o una fracción del número de muestras (redondeado para ser al menos 2). Si
ninguno, se utiliza el valor de min_samples en su lugar. Se usa solo cuando
cluster_method = 'xi'.

algoritmo {'auto', 'ball_tree', 'kd_tree', 'brute'}, opcional

Algoritmo utilizado para calcular los vecinos más cercanos:
'Ball_tree' usará BallTree
"Kd_tree" usará KDTree
"Bruto" utilizará una búsqueda de fuerza bruta.
"Auto" intentará decidir el algoritmo más adecuado en función de los valores pasados al
método de ajuste. (defecto)
Nota: el ajuste en una entrada dispersa anulará la configuración de este parámetro,
utilizando la fuerza bruta.

leaf_sizeint, opcional (predeterminado = 30)

El tamaño de la hoja pasó a BallTree o KDTree. Esto puede afectar la velocidad de la
construcción y la consulta, así como la memoria requerida para almacenar el árbol. El
valor óptimo depende de la naturaleza del problema.

n_jobsint o None, opcional (predeterminado = Ninguno)

El número de trabajos paralelos que se ejecutarán para la búsqueda de vecinos.
Ninguno significa 1 a menos que se encuentre en un contexto joblib.parallel_backend.
-1 significa usar todos los procesadores. Ver Glosario para más detalles.