Hay tres enfoques diferentes para el aprendizaje automático, según los datos que tenga. Puede optar por el aprendizaje supervisado, el aprendizaje semi-supervisado o el aprendizaje no supervisado.
En el aprendizaje supervisado, ha etiquetado los datos, por lo que tiene salidas que sabe con certeza que son los valores correctos para sus entradas. Es como conocer los precios de los automóviles en función de características como marca, modelo, estilo, transmisión y otros atributos.
Con el aprendizaje semi-supervisado, tiene un gran conjunto de datos donde algunos de los datos están etiquetados pero la mayoría no.
Esto cubre una gran cantidad de datos del mundo real porque puede ser costoso conseguir que un experto etiquete cada punto de datos. Puede solucionar este problema utilizando una combinación de aprendizaje supervisado y no supervisado.
El aprendizaje no supervisado significa que tiene un conjunto de datos que no tiene etiquetas. No sabe si hay patrones ocultos en los datos, por lo que deja que el algoritmo encuentre todo lo que pueda.
Ahí es donde entran en juego los algoritmos de agrupamiento. Es uno de los métodos que puede utilizar en un problema de aprendizaje no supervisado.
¿Qué son los algoritmos de agrupación en clústeres?
La agrupación en clústeres es una tarea de aprendizaje automático no supervisada. Es posible que también escuche que se hace referencia a esto como análisis de conglomerados debido a la forma en que funciona este método.
El uso de un algoritmo de agrupación en clústeres significa que le dará al algoritmo una gran cantidad de datos de entrada sin etiquetas y le permitirá encontrar cualquier agrupación en los datos que pueda.
Esas agrupaciones se denominan agrupaciones . Un clúster es un grupo de puntos de datos que son similares entre sí en función de su relación con los puntos de datos circundantes. La agrupación en clústeres se utiliza para cosas como la ingeniería de características o el descubrimiento de patrones.
Cuando comienza con datos de los que no sabe nada, la agrupación en clústeres puede ser un buen lugar para obtener información.
Tipos de algoritmos de agrupamiento
Existen diferentes tipos de algoritmos de agrupamiento que manejan todo tipo de datos únicos.
Basado en densidad
En el agrupamiento basado en densidad, los datos se agrupan por áreas de altas concentraciones de puntos de datos rodeadas por áreas de bajas concentraciones de puntos de datos. Básicamente, el algoritmo encuentra los lugares que son densos con puntos de datos y llama a esos grupos.
Lo bueno de esto es que los grupos pueden tener cualquier forma. No está limitado a las condiciones esperadas.
Los algoritmos de agrupación en clústeres de este tipo no intentan asignar valores atípicos a los clústeres, por lo que se ignoran.
Basado en distribución
Con un enfoque de agrupamiento basado en distribución, todos los puntos de datos se consideran partes de un grupo en función de la probabilidad de que pertenezcan a un grupo determinado.
Funciona así: hay un punto central y, a medida que aumenta la distancia entre un punto de datos y el centro, la probabilidad de que forme parte de ese grupo disminuye.
Si no está seguro de cómo podría ser la distribución de sus datos, debería considerar un tipo diferente de algoritmo.
Basado en centroides
La agrupación en clústeres basada en centroides es la que probablemente escuche más. Es un poco sensible a los parámetros iniciales que le da, pero es rápido y eficiente.
Estos tipos de algoritmos separan los puntos de datos en función de múltiples centroides en los datos. Cada punto de datos se asigna a un grupo en función de su distancia al cuadrado del centroide. Este es el tipo de agrupación más utilizado.
Basado en jerarquías
La agrupación en clústeres basada en jerarquías se utiliza normalmente en datos jerárquicos, como se obtendría de una base de datos de empresa o taxonomías. Construye un árbol de grupos para que todo esté organizado de arriba hacia abajo.
Esto es más restrictivo que los otros tipos de clústeres, pero es perfecto para tipos específicos de conjuntos de datos.
Cuándo usar la agrupación en clústeres
Cuando tienes un conjunto de datos sin etiquetar, es muy probable que estés usando algún tipo de algoritmo de aprendizaje sin supervisión.
Hay muchas técnicas diferentes de aprendizaje no supervisado, como redes neuronales, aprendizaje por refuerzo y agrupamiento. El tipo específico de algoritmo que desea utilizar dependerá de cómo se vean sus datos.
Es posible que desee utilizar la agrupación en clústeres cuando intente realizar una detección de anomalías para intentar encontrar valores atípicos en sus datos. Ayuda a encontrar esos grupos de clústeres y muestra los límites que determinarían si un punto de datos es un valor atípico o no.
Si no está seguro de qué funciones usar para su modelo de aprendizaje automático, la agrupación en clústeres descubre patrones que puede usar para descubrir qué se destaca en los datos.
La agrupación en clústeres es especialmente útil para explorar datos de los que no sabe nada. Puede llevar algún tiempo averiguar qué tipo de algoritmo de agrupación en clústeres funciona mejor, pero cuando lo haga, obtendrá información invaluable sobre sus datos. Es posible que encuentre conexiones en las que nunca hubiera pensado.
Algunas aplicaciones del mundo real de la agrupación en clústeres incluyen la detección de fraudes en los seguros, la categorización de libros en una biblioteca y la segmentación de clientes en marketing. También se puede utilizar en problemas más grandes, como análisis de terremotos o planificación urbana.
Los 8 mejores algoritmos de agrupamiento
Ahora que tiene algunos antecedentes sobre cómo funcionan los algoritmos de agrupación en clústeres y los diferentes tipos disponibles, podemos hablar sobre los algoritmos reales que verá comúnmente en la práctica.
Implementaremos estos algoritmos en un conjunto de datos de ejemplo de la biblioteca sklearn en Python.
Usaremos el conjunto de datos make_classification de la biblioteca sklearn para demostrar cómo los diferentes algoritmos de agrupamiento no son adecuados para todos los problemas de agrupamiento.
Puede encontrar el código para todos los siguientes ejemplos aquí.
Algoritmo de agrupación de K-means
La agrupación en clústeres de K-means es el algoritmo de agrupación en clúster más utilizado. Es un algoritmo basado en centroides y el algoritmo de aprendizaje no supervisado más simple.
Este algoritmo intenta minimizar la varianza de los puntos de datos dentro de un grupo. También es la forma en que la mayoría de las personas se familiarizan con el aprendizaje automático sin supervisión.
K-means se usa mejor en conjuntos de datos más pequeños porque itera sobre todos los puntos de datos. Eso significa que tomará más tiempo clasificar los puntos de datos si hay una gran cantidad de ellos en el conjunto de datos.
Dado que así es como k-means agrupa los puntos de datos, no se escala bien.
Implementación:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import KMeans # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model kmeans_model = KMeans(n_clusters=2) # assign each data point to a cluster dbscan_result = dbscan_model.fit_predict(training_data) # get all of the unique clusters dbscan_clusters = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters: # get data points that fall in this cluster index = where(dbscan_result == dbscan_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()Algoritmo de agrupación en clústeres DBSCAN
DBSCAN significa agrupación espacial basada en densidad de aplicaciones con ruido. Es un algoritmo de agrupamiento basado en densidad, a diferencia de k-means.
Este es un buen algoritmo para encontrar esquemas en un conjunto de datos. Encuentra grupos de forma arbitraria en función de la densidad de puntos de datos en diferentes regiones. Separa las regiones por áreas de baja densidad para que pueda detectar valores atípicos entre los grupos de alta densidad.
Este algoritmo es mejor que k-means cuando se trata de trabajar con datos de formas extrañas.
DBSCAN utiliza dos parámetros para determinar cómo se definen los grupos: minPts (el número mínimo de puntos de datos que deben agruparse para que un área se considere de alta densidad) y eps (la distancia utilizada para determinar si un punto de datos está en el misma área que otros puntos de datos).
La elección de los parámetros iniciales correctos es fundamental para que este algoritmo funcione.
Implementación:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import DBSCAN # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model dbscan_model = DBSCAN(eps=0.25, min_samples=9) # train the model dbscan_model.fit(training_data) # assign each data point to a cluster dbscan_result = dbscan_model.predict(training_data) # get all of the unique clusters dbscan_cluster = unique(dbscan_result) # plot the DBSCAN clusters for dbscan_cluster in dbscan_clusters: # get data points that fall in this cluster index = where(dbscan_result == dbscan_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the DBSCAN plot pyplot.show()Algoritmo del modelo de mezcla gaussiana
Uno de los problemas con k-means es que los datos deben seguir un formato circular. La forma en que k-means calcula la distancia entre puntos de datos tiene que ver con una ruta circular, por lo que los datos no circulares no se agrupan correctamente.
Este es un problema que solucionan los modelos de mezcla gaussianos. No necesita datos de forma circular para que funcione bien.
El modelo de mezcla gaussiana utiliza múltiples distribuciones gaussianas para ajustar datos de forma arbitraria.
Hay varios modelos gaussianos únicos que actúan como capas ocultas en este modelo híbrido. Entonces, el modelo calcula la probabilidad de que un punto de datos pertenezca a una distribución gaussiana específica y ese es el grupo en el que se ubicará.
Implementación:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.mixture import GaussianMixture # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model gaussian_model = GaussianMixture(n_components=2) # train the model gaussian_model.fit(training_data) # assign each data point to a cluster gaussian_result = gaussian_model.predict(training_data) # get all of the unique clusters gaussian_clusters = unique(gaussian_result) # plot Gaussian Mixture the clusters for gaussian_cluster in gaussian_clusters: # get data points that fall in this cluster index = where(gaussian_result == gaussian_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Gaussian Mixture plot pyplot.show()Algoritmo BIRCH
El algoritmo Balance Iterative Reducing and Clustering using Hierarchies (BIRCH) funciona mejor en conjuntos de datos grandes que el algoritmo k-means.
Divide los datos en pequeños resúmenes que se agrupan en lugar de los puntos de datos originales. Los resúmenes contienen tanta información de distribución sobre los puntos de datos como sea posible.
Este algoritmo se usa comúnmente con otros algoritmos de agrupamiento porque las otras técnicas de agrupamiento se pueden usar en los resúmenes generados por BIRCH.
La principal desventaja del algoritmo BIRCH es que solo funciona con valores de datos numéricos. No puede usar esto para valores categóricos a menos que realice algunas transformaciones de datos.
Implementación:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import Birch # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model birch_model = Birch(threshold=0.03, n_clusters=2) # train the model birch_model.fit(training_data) # assign each data point to a cluster birch_result = birch_model.predict(training_data) # get all of the unique clusters birch_clusters = unique(birch_result) # plot the BIRCH clusters for birch_cluster in birch_clusters: # get data points that fall in this cluster index = where(birch_result == birch_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the BIRCH plot pyplot.show() Algoritmo de agrupación en clústeres de propagación de afinidad
Este algoritmo de agrupación es completamente diferente de los demás en la forma en que agrupa los datos.
Cada punto de datos se comunica con todos los demás puntos de datos para que los demás sepan qué tan similares son y eso comienza a revelar los grupos en los datos. No tiene que decirle a este algoritmo cuántos clústeres esperar en los parámetros de inicialización.
A medida que se envían mensajes entre puntos de datos, se encuentran conjuntos de datos denominados ejemplos y representan los grupos.
An exemplar is found after the data points have passed messages to each other and form a consensus on what data point best represents a cluster.
When you aren't sure how many clusters to expect, like in a computer vision problem, this is a great algorithm to start with.
Implementation:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AffinityPropagation # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model model = AffinityPropagation(damping=0.7) # train the model model.fit(training_data) # assign each data point to a cluster result = model.predict(training_data) # get all of the unique clusters clusters = unique(result) # plot the clusters for cluster in clusters: # get data points that fall in this cluster index = where(result == cluster) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the plot pyplot.show()Mean-Shift clustering algorithm
This is another algorithm that is particularly useful for handling images and computer vision processing.
Mean-shift is similar to the BIRCH algorithm because it also finds clusters without an initial number of clusters being set.
This is a hierarchical clustering algorithm, but the downside is that it doesn't scale well when working with large data sets.
It works by iterating over all of the data points and shifts them towards the mode. The mode in this context is the high density area of data points in a region.
That's why you might hear this algorithm referred to as the mode-seeking algorithm. It will go through this iterative process with each data point and move them closer to where other data points are until all data points have been assigned to a cluster.
Implementation:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import MeanShift # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model mean_model = MeanShift() # assign each data point to a cluster mean_result = mean_model.fit_predict(training_data) # get all of the unique clusters mean_clusters = unique(mean_result) # plot Mean-Shift the clusters for mean_cluster in mean_clusters: # get data points that fall in this cluster index = where(mean_result == mean_cluster) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Mean-Shift plot pyplot.show()OPTICS algorithm
OPTICS stands for Ordering Points to Identify the Clustering Structure. It's a density-based algorithm similar to DBSCAN, but it's better because it can find meaningful clusters in data that varies in density. It does this by ordering the data points so that the closest points are neighbors in the ordering.
This makes it easier to detect different density clusters. The OPTICS algorithm only processes each data point once, similar to DBSCAN (although it runs slower than DBSCAN). There's also a special distance stored for each data point that indicates a point belongs to a specific cluster.
Implementation:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import OPTICS # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model optics_model = OPTICS(eps=0.75, min_samples=10) # assign each data point to a cluster optics_result = optics_model.fit_predict(training_data) # get all of the unique clusters optics_clusters = unique(optics_clusters) # plot OPTICS the clusters for optics_cluster in optics_clusters: # get data points that fall in this cluster index = where(optics_result == optics_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the OPTICS plot pyplot.show()Agglomerative Hierarchy clustering algorithm
This is the most common type of hierarchical clustering algorithm. It's used to group objects in clusters based on how similar they are to each other.
This is a form of bottom-up clustering, where each data point is assigned to its own cluster. Then those clusters get joined together.
At each iteration, similar clusters are merged until all of the data points are part of one big root cluster.
Agglomerative clustering is best at finding small clusters. The end result looks like a dendrogram so that you can easily visualize the clusters when the algorithm finishes.
Implementation:
from numpy import unique from numpy import where from matplotlib import pyplot from sklearn.datasets import make_classification from sklearn.cluster import AgglomerativeClustering # initialize the data set we'll work with training_data, _ = make_classification( n_samples=1000, n_features=2, n_informative=2, n_redundant=0, n_clusters_per_class=1, random_state=4 ) # define the model agglomerative_model = AgglomerativeClustering(n_clusters=2) # assign each data point to a cluster agglomerative_result = agglomerative_model.fit_predict(training_data) # get all of the unique clusters agglomerative_clusters = unique(agglomerative_result) # plot the clusters for agglomerative_cluster in agglomerative_clusters: # get data points that fall in this cluster index = where(agglomerative_result == agglomerative_clusters) # make the plot pyplot.scatter(training_data[index, 0], training_data[index, 1]) # show the Agglomerative Hierarchy plot pyplot.show()Other types of clustering algorithms
We've covered eight of the top clustering algorithms, but there are plenty more than that available. There are some very specifically tuned clustering algorithms that quickly and precisely handle your data. Here are a few of the others that might be of interest to you.
There's another hierarchical algorithm that's the opposite of the agglomerative approach. It starts with a top-down clustering strategy. So it will start with one large root cluster and break out the individual clusters from there.
This is known as the Divisive Hierarchical clustering algorithm. There's research that shows this is creates more accurate hierarchies than agglomerative clustering, but it's way more complex.
Mini-Batch K-means is similar to K-means, except that it uses small random chunks of data of a fixed size so they can be stored in memory. This helps it run faster than K-means so it converges to a solution in less time.
The drawback to this algorithm is that the speed boost will cost you some cluster quality.
The last algorithm we'll briefly cover is Spectral Clustering. This algorithm is completely different from the others we've looked at.
It works by taking advantage of graph theory. This algorithm doesn't make any initial guesses about the clusters that are in the data set. It treats data points like nodes in a graph and clusters are found based on communities of nodes that have connecting edges.
Other thoughts
Watch out for scaling issues with the clustering algorithms. Your data set could have millions of data points, and since clustering algorithms work by calculating the similarities between all pairs of data points, you might end up with an algorithm that doesn’t scale well.
Conclusion
Clustering algorithms are a great way to learn new things from old data. Sometimes you'll be surprised by the resulting clusters you get and it might help you make sense of a problem.
One of the coolest things about using clustering for unsupervised learning is that you can use the results in a supervised learning problem.
The clusters could be your new features that you use on a completely different data set! You can use clustering on just about any unsupervised machine learning problem, but make sure that you know how to analyze the results for accuracy.