IA con Python - Aprendizaje no supervisado: agrupación

Los algoritmos de aprendizaje automático no supervisados ​​no tienen ningún supervisor que proporcione ningún tipo de orientación. Por eso están estrechamente alineados con lo que algunos llaman verdadera inteligencia artificial.

En el aprendizaje no supervisado, no habría una respuesta correcta ni un maestro para la orientación. Los algoritmos necesitan descubrir el patrón interesante en los datos para el aprendizaje.

¿Qué es la agrupación en clústeres?

Básicamente, es un tipo de método de aprendizaje no supervisado y una técnica común para el análisis de datos estadísticos que se utiliza en muchos campos. El agrupamiento principalmente es una tarea de dividir el conjunto de observaciones en subconjuntos, llamados grupos, de tal manera que las observaciones en el mismo grupo sean similares en un sentido y diferentes a las observaciones en otros grupos. En palabras simples, podemos decir que el objetivo principal de la agrupación es agrupar los datos sobre la base de similitudes y diferencias.

Por ejemplo, el siguiente diagrama muestra tipos similares de datos en diferentes clústeres:

Algoritmos para agrupar los datos

A continuación, se muestran algunos algoritmos comunes para agrupar los datos:

Algoritmo K-Means

El algoritmo de agrupación de K-means es uno de los algoritmos más conocidos para agrupar los datos. Debemos asumir que ya se conoce el número de conglomerados. Esto también se llama agrupación plana. Es un algoritmo de agrupamiento iterativo. Los pasos que se indican a continuación deben seguirse para este algoritmo:

Step 1 - Necesitamos especificar el número deseado de K subgrupos.

Step 2- Fije la cantidad de grupos y asigne aleatoriamente cada punto de datos a un grupo. O en otras palabras, necesitamos clasificar nuestros datos en función del número de grupos.

En este paso, se deben calcular los centroides del grupo.

Como se trata de un algoritmo iterativo, necesitamos actualizar las ubicaciones de K centroides con cada iteración hasta que encontremos los óptimos globales o, en otras palabras, los centroides alcanzan sus ubicaciones óptimas.

El siguiente código ayudará a implementar el algoritmo de agrupación de K-means en Python. Vamos a utilizar el módulo Scikit-learn.

Importamos los paquetes necesarios -

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

La siguiente línea de código ayudará a generar el conjunto de datos bidimensional, que contiene cuatro blobs, utilizando make_blob desde el sklearn.dataset paquete.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4,
            cluster_std = 0.40, random_state = 0)

Podemos visualizar el conjunto de datos usando el siguiente código:

plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()

Aquí, estamos inicializando kmeans para que sea el algoritmo de KMeans, con el parámetro requerido de cuántos clústeres (n_clusters).

kmeans = KMeans(n_clusters = 4)

Necesitamos entrenar el modelo de K-medias con los datos de entrada.

kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')

centers = kmeans.cluster_centers_

El código que se proporciona a continuación nos ayudará a trazar y visualizar los hallazgos de la máquina en función de nuestros datos y el ajuste de acuerdo con la cantidad de grupos que se van a encontrar.

plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()

Algoritmo de cambio medio

Es otro algoritmo de agrupación popular y poderoso que se utiliza en el aprendizaje no supervisado. No hace ninguna suposición, por lo que es un algoritmo no paramétrico. También se denomina agrupación jerárquica o análisis de agrupación de turnos medios. Los siguientes serían los pasos básicos de este algoritmo:

  • En primer lugar, debemos comenzar con los puntos de datos asignados a un grupo propio.

  • Ahora, calcula los centroides y actualiza la ubicación de los nuevos centroides.

  • Al repetir este proceso, nos acercamos al pico del clúster, es decir, hacia la región de mayor densidad.

  • Este algoritmo se detiene en la etapa donde los centroides ya no se mueven.

Con la ayuda del siguiente código, estamos implementando el algoritmo de agrupación en clústeres de Mean Shift en Python. Vamos a utilizar el módulo Scikit-learn.

Importamos los paquetes necesarios -

import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")

El siguiente código ayudará a generar el conjunto de datos bidimensional, que contiene cuatro blobs, utilizando make_blob desde el sklearn.dataset paquete.

from sklearn.datasets.samples_generator import make_blobs

Podemos visualizar el conjunto de datos con el siguiente código

centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()

Ahora, necesitamos entrenar el modelo de clúster de cambio medio con los datos de entrada.

ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_

El siguiente código imprimirá los centros del clúster y el número esperado de clúster según los datos de entrada:

print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2

El código que se proporciona a continuación ayudará a trazar y visualizar los hallazgos de la máquina en función de nuestros datos y el ajuste de acuerdo con la cantidad de grupos que se encontrarán.

colors = 10*['r.','g.','b.','c.','k.','y.','m.']
   for i in range(len(X)):
   plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
   marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()

Medir el rendimiento de la agrupación en clústeres

Los datos del mundo real no se organizan de forma natural en varios grupos distintivos. Por esta razón, no es fácil visualizar y hacer inferencias. Es por eso que necesitamos medir el rendimiento de la agrupación en clústeres, así como su calidad. Se puede hacer con la ayuda del análisis de silueta.

Análisis de silueta

Este método se puede utilizar para comprobar la calidad de la agrupación midiendo la distancia entre las agrupaciones. Básicamente, proporciona una forma de evaluar los parámetros como el número de clústeres dando una puntuación de silueta. Esta puntuación es una métrica que mide qué tan cerca está cada punto de un grupo de los puntos de los grupos vecinos.

Análisis de puntuación de silueta

La puntuación tiene un rango de [-1, 1]. A continuación se muestra el análisis de esta puntuación:

  • Score of +1 - Una puntuación cercana a +1 indica que la muestra está lejos del grupo vecino.

  • Score of 0 - La puntuación 0 indica que la muestra se encuentra en o muy cerca del límite de decisión entre dos conglomerados vecinos.

  • Score of -1 - La puntuación negativa indica que las muestras se han asignado a grupos incorrectos.

Calcular la puntuación de silueta

En esta sección, aprenderemos a calcular la puntuación de silueta.

La puntuación de silueta se puede calcular utilizando la siguiente fórmula:

$$ silueta puntuación = \ frac {\ left (pq \ right)} {max \ left (p, q \ right)} $$

Aquí, es la distancia media a los puntos en el grupo más cercano del que el punto de datos no forma parte. Y es la distancia media dentro del grupo a todos los puntos en su propio grupo.

Para encontrar el número óptimo de clústeres, necesitamos ejecutar el algoritmo de clústeres nuevamente importando el metrics módulo del sklearnpaquete. En el siguiente ejemplo, ejecutaremos el algoritmo de agrupación en clústeres K-means para encontrar el número óptimo de clústeres:

Importe los paquetes necesarios como se muestra:

import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans

Con la ayuda del siguiente código, generaremos el conjunto de datos bidimensional, que contiene cuatro blobs, usando make_blob desde el sklearn.dataset paquete.

from sklearn.datasets.samples_generator import make_blobs

X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)

Inicialice las variables como se muestra -

scores = []
values = np.arange(2, 10)

Necesitamos iterar el modelo K-means a través de todos los valores y también necesitamos entrenarlo con los datos de entrada.

for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)

Ahora, calcule la puntuación de silueta para el modelo de agrupamiento actual utilizando la métrica de distancia euclidiana:

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

La siguiente línea de código ayudará a mostrar el número de clústeres y la puntuación de Silhouette.

print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)

Recibirá el siguiente resultado:

Number of clusters = 9
Silhouette score = 0.340391138371

num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)

Ahora, la salida para la cantidad óptima de clústeres sería la siguiente:

Optimal number of clusters = 2

Encontrar vecinos más cercanos

Si queremos construir sistemas de recomendación, como un sistema de recomendación de películas, necesitamos comprender el concepto de encontrar los vecinos más cercanos. Es porque el sistema de recomendación utiliza el concepto de vecinos más cercanos.

los concept of finding nearest neighborspuede definirse como el proceso de encontrar el punto más cercano al punto de entrada del conjunto de datos dado. El uso principal de este algoritmo KNN (K-vecinos más cercanos) es construir sistemas de clasificación que clasifiquen un punto de datos sobre la proximidad del punto de datos de entrada a varias clases.

El código de Python que se proporciona a continuación ayuda a encontrar los K vecinos más cercanos de un conjunto de datos dado:

Importe los paquetes necesarios como se muestra a continuación. Aquí, estamos usando elNearestNeighbors módulo del sklearn paquete

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors

Definamos ahora los datos de entrada:

A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9], 
             [8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])

Ahora, necesitamos definir los vecinos más cercanos:

k = 3

También necesitamos proporcionar los datos de prueba a partir de los cuales se encontrarán los vecinos más cercanos:

test_data = [3.3, 2.9]

El siguiente código puede visualizar y trazar los datos de entrada definidos por nosotros:

plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')

Ahora, necesitamos construir el vecino más cercano K. El objeto también necesita ser entrenado

knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])

Ahora, podemos imprimir los K vecinos más cercanos de la siguiente manera

print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
   print(str(rank) + " is", A[index])

Podemos visualizar los vecinos más cercanos junto con el punto de datos de prueba.

plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
   marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
   marker = 'x', s = 100, color = 'k')
plt.show()

Salida

K Nearest Neighbors

1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]

Clasificador K-Vecinos más cercanos

Un clasificador de K-vecinos más cercanos (KNN) es un modelo de clasificación que utiliza el algoritmo de vecinos más cercanos para clasificar un punto de datos dado. Hemos implementado el algoritmo KNN en la última sección, ahora vamos a construir un clasificador KNN usando ese algoritmo.

Concepto de clasificador KNN

El concepto básico de la clasificación de K-vecino más cercano es encontrar un número predefinido, es decir, la 'k' - de muestras de entrenamiento más cercanas en distancia a una nueva muestra, que tiene que ser clasificada. Las nuevas muestras obtendrán su etiqueta de los propios vecinos. Los clasificadores KNN tienen una constante definida por el usuario fija para el número de vecinos que deben determinarse. Para la distancia, la distancia euclidiana estándar es la opción más común. El clasificador KNN trabaja directamente en las muestras aprendidas en lugar de crear las reglas para el aprendizaje. El algoritmo KNN se encuentra entre los más simples de todos los algoritmos de aprendizaje automático. Ha tenido bastante éxito en una gran cantidad de problemas de clasificación y regresión, por ejemplo, reconocimiento de caracteres o análisis de imágenes.

Example

Estamos construyendo un clasificador KNN para reconocer dígitos. Para esto, usaremos el conjunto de datos MNIST. Escribiremos este código en el Jupyter Notebook.

Importe los paquetes necesarios como se muestra a continuación.

Aquí estamos usando el KNeighborsClassifier módulo del sklearn.neighbors paquete -

from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np

El siguiente código mostrará la imagen del dígito para verificar qué imagen tenemos que probar -

def Image_display(i):
   plt.imshow(digit['images'][i],cmap = 'Greys_r')
   plt.show()

Ahora, necesitamos cargar el conjunto de datos MNIST. En realidad, hay un total de 1797 imágenes, pero estamos usando las primeras 1600 imágenes como muestra de entrenamiento y las 197 restantes se conservarían para fines de prueba.

digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])

Ahora, al mostrar las imágenes, podemos ver el resultado de la siguiente manera:

Image_display(0)

Visualización_imagen (0)

La imagen de 0 se muestra de la siguiente manera:

Visualización_imagen (9)

La imagen de 9 se muestra de la siguiente manera:

teclas.digitales ()

Ahora, necesitamos crear el conjunto de datos de entrenamiento y prueba y suministrar el conjunto de datos de prueba a los clasificadores KNN.

train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)

La siguiente salida creará el constructor del clasificador K vecino más cercano:

KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
   weights = 'uniform')

Necesitamos crear la muestra de prueba proporcionando cualquier número arbitrario mayor que 1600, que eran las muestras de entrenamiento.

test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)

Visualización_imagen (6)

La imagen de 6 se muestra de la siguiente manera:

Ahora predeciremos los datos de la prueba de la siguiente manera:

KNN.predict(test1)

El código anterior generará la siguiente salida:

array([6])

Ahora, considere lo siguiente:

digit['target_names']

El código anterior generará la siguiente salida:

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])