1. Description
Le modèle de mélange gaussien (GMM) est une technique d'analyse groupée basée sur l'estimation de la densité de probabilité. Il suppose que les points de données sont générés par un mélange de plusieurs distributions gaussiennes avec des moyennes et des variances différentes. Il peut fournir des résultats de clustering efficaces dans certains résultats.
2. Efficacité de l'algorithme Kmean
L'algorithme de clustering K-means place une limite circulaire autour du centre de chaque cluster. Cette méthode fonctionne bien lorsque les données ont des formes circulaires.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
np.random.seed(42)
def generate_circular(n_samples=500):
X = np.concatenate((
np.random.normal(0, 1, (n_samples, 2)),
np.random.normal(5, 1, (n_samples, 2)),
np.random.normal(10, 1, (n_samples, 2))
))
return X
X = generate_circular()
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans_labels = kmeans.fit_predict(X)
# boundaries of the cluster spheres
radii = [np.max(np.linalg.norm(X[kmeans_labels == i, :] - kmeans.cluster_centers_[i, :], axis=1))
for i in range(3)]
# plot
fig, ax = plt.subplots(ncols=2, figsize=(10, 4))
ax[0].scatter(X[:, 0], X[:, 1])
ax[0].set_title("Data")
ax[1].scatter(X[:, 0], X[:, 1], c=kmeans_labels)
ax[1].scatter(kmeans.cluster_centers_[:, 0], kmeans.cluster_centers_[:, 1],
marker='x', s=200, linewidth=3, color='r')
for i in range(3):
ax[1].add_artist(plt.Circle(kmeans.cluster_centers_[i, :], radius=radii[i], color='r', fill=False, lw=2))
ax[1].set_title("K Means Clustering")
plt.show()
Toutefois, cette méthode peut ne pas fonctionner lorsque les données ont des formes différentes, telles que des rectangles ou des ovales.
import numpy as np
import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
np.random.seed(42)
def generate_elliptic(n_samples=500):
X = np.concatenate((
np.random.normal([0, 3], [0.3, 1], (n_samples, 2)),
np.random.normal([2, 4], [0.3, 1], (n_samples, 2)),
np.random.normal([4, 6], [0.4, 1], (n_samples, 2))
))
return X
X = generate_elliptic()
kmeans = KMeans(n_clusters=3, random_state=42)
kmeans_labels = kmeans.fit_predict(X)
kmeans_cluster_centers = kmeans.cluster_centers_
# the radius of each cluster
kmeans_cluster_radii = [np.max(np.linalg.norm(X[kmeans_labels == i, :] - kmeans.cluster_centers_[i, :], axis=1))
for i in range(3)]
# plot
fig, ax = plt.subplots(ncols=2, figsize=(10, 4))
ax[0].scatter(X[:, 0], X[:, 1])
ax[0].set_title("data")
ax[1].scatter(X[:, 0], X[:, 1], c=kmeans_labels)
ax[1].scatter(kmeans_cluster_centers[:, 0], kmeans_cluster_centers[:, 1],
marker='x', s=200, linewidth=3, color='r')
for i in range(3):
circle = plt.Circle(kmeans_cluster_centers[i], kmeans_cluster_radii[i], color='r', fill=False)
ax[1].add_artist(circle)
ax[1].set_title("k-means clustering")
plt.xlim(-4, 10)
plt.ylim(-4, 10)
plt.show()
3. GMM plus avancé que K-mean
GMM étend le modèle K-means en utilisant la distribution gaussienne pour représenter le clustering. Contrairement aux K-means, GMM capture non seulement la moyenne mais aussi la covariance des clusters, permettant de modéliser leur forme ellipsoïdale. Pour ajuster le GMM, nous utilisons l'algorithme de maximisation des attentes (EM), qui maximise la probabilité des données observées. EM est similaire à K-means, mais attribue des points de données à des clusters avec des probabilités douces au lieu d'affectations strictes.
À un niveau élevé, GMM combine plusieurs distributions gaussiennes pour modéliser les données. Au lieu d'identifier les clusters en fonction de leurs centroïdes les plus proches, un ensemble de k gaussiennes est ajusté aux données et des paramètres tels que la moyenne, la variance et le poids sont estimés pour chaque cluster. Une fois que vous connaissez les paramètres de chaque point de données, vous pouvez calculer la probabilité pour déterminer à quel cluster appartient le point.
Chaque distribution est pondérée par un facteur de pondération (π) pour tenir compte du nombre différent d'échantillons dans la grappe. Par exemple, si nous n'avons que 1 000 points de données du cluster rouge, mais 100 000 points de données du cluster vert, nous pondérerons plus étroitement la distribution du cluster rouge pour garantir qu'elle a un impact significatif sur la distribution globale.
Composants. source
L'algorithme GMM se compose de deux étapes : l'attente (E) et la maximisation (M).
La première étape, appelée étape d'espérance ou étape E, consiste à calculer l'espérance de l'affectation des composants Ck pour chaque point de données xi∈X étant donné les paramètres du modèle πk μk et σk.
La deuxième étape est appelée étape de maximisation ou étape M, et elle consiste à maximiser les attentes calculées dans l'étape E par rapport aux paramètres du modèle. Cette étape comprend la mise à jour des valeurs πk, μk et σk.
L’ensemble du processus itératif est répété jusqu’à ce que l’algorithme converge, donnant une estimation du maximum de vraisemblance. Intuitivement, cet algorithme fonctionne parce que connaître les affectations de composants Ck pour chaque xi facilite la résolution de πk μk et σk, et connaître πk μk σk facilite la déduction de p(Ck|xi).
L'étape d'attente correspond à ce dernier cas, tandis que l'étape de maximisation correspond au premier cas. Par conséquent, les estimations du maximum de vraisemblance pour les valeurs non fixes peuvent être calculées efficacement en alternant entre l'hypothèse de valeurs fixes ou de valeurs connues.
algorithme
- Initialisez la moyenne (μk), la matrice de covariance (σk) et les coefficients de mélange (πk) avec des valeurs aléatoires ou prédéfinies.
- Calculez la distribution des composants (Ck) pour tous les clusters.
- Tous les paramètres sont estimés en utilisant l'allocation actuelle des composants (Ck).
- Calcule la fonction de log-vraisemblance.
- Définir des critères de convergence.
- Arrêtez l'algorithme si la valeur du log de vraisemblance converge vers un seuil spécifique ou si tous les paramètres convergent vers une valeur spécifique. Sinon, revenez à l'étape 2.
Il est à noter que cet algorithme garantit une convergence vers l'optimum local, mais il ne garantit pas que cet optimum local soit également l'optimum global. Par conséquent, si l’algorithme démarre avec une initialisation différente, il peut en résulter des configurations différentes.
4.code python
from sklearn.mixture import GaussianMixture
paramètre:
n_componentsest le nombre de clusters.covariance_typeDétermine le type de matrice de covariance utilisée par le GMM. Il peut prendre les valeurs suivantes : : Chaque composant du mélange a sa matrice de covariance universelle. : Tous les composants du mélange partagent la même matrice de covariance générale. : Chaque composant du mélange a sa matrice de covariance diagonale. : Chaque composant du mélange a sa valeur de variance individuelle, ce qui donne une matrice de covariance sphérique.fulltieddiagsphericaltolContrôle le seuil de convergence de l'algorithme EM. Il s'arrête lorsque l'amélioration de la probabilité logarithmique tombe en dessous de ce seuil.reg_covarDes termes de régularisation sont ajoutés dans la diagonale de la matrice de covariance pour assurer la stabilité numérique lors des calculs. Cela permet d'éviter les problèmes potentiels liés aux matrices de covariance singulières ou mal conditionnées.max_iterest le nombre d'itérations EM.n_initContrôle l'initialisation des paramètres du modèle. Il peut prendre les valeurs suivantes : " kmeans : La moyenne initiale est estimée à l'aide de l'algorithme K-means. random " : La moyenne initiale est sélectionnée aléatoirement parmi les données, et les coefficients de covariance et de mélange sont initialisés.weights_initSpécifiez manuellement le poids initial (coefficient de mélange) de chaque composant.means_initSpécifiez manuellement le vecteur moyen initial pour chaque composant.precision_initSpécifiez manuellement la matrice de précision initiale (l'inverse de la matrice de covariance) pour chaque composant.
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
def generate_elliptic(n_samples=500):
X = np.concatenate((
np.random.normal([0, 3], [0.3, 1], (n_samples, 2)),
np.random.normal([2, 4], [0.3, 1], (n_samples, 2)),
np.random.normal([4, 6], [0.4, 1], (n_samples, 2))
))
return X
X = generate_elliptic()
# k-means clustering
kmeans = KMeans(n_clusters=3, random_state=0).fit(X)
kmeans_labels = kmeans.labels_
# Gaussian mixture clustering
gmm = GaussianMixture(n_components=3, random_state=0).fit(X)
gmm_labels = gmm.predict(X)
# Plot the clustering results
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].scatter(X[:, 0], X[:, 1], c=kmeans_labels)
axs[0].set_title('K-means clustering')
axs[1].scatter(X[:, 0], X[:, 1], c=gmm_labels)
axs[1].set_title('Gaussian mixture clustering')
plt.show()
K-moyennes vs gaussiennes. Image de l'auteur.
print("Weights: ", gmm.weights_)
print("Means: ", gmm.means_)
print("Covariances: ", gmm.covariances_)
print("Precisions: ", gmm.precisions_)
"""
Weights: [0.33300331 0.33410451 0.33289218]
Means: [[ 1.98104152e+00 3.95197560e+00]
[ 3.98369464e+00 5.93920471e+00]
[-4.67796574e-03 2.97097723e+00]]
Covariances: [[[ 0.08521068 -0.00778594]
[-0.00778594 1.01699345]]
[[ 0.16066983 -0.01669341]
[-0.01669341 1.0383678 ]]
[[ 0.09482093 0.00709653]
[ 0.00709653 1.03641711]]]
Precisions: [[[11.74383346 0.08990895]
[ 0.08990895 0.98397883]]
[[ 6.23435734 0.10022716]
[ 0.10022716 0.9646612 ]]
[[10.55160153 -0.07224865]
[-0.07224865 0.96535719]]]
"""5. Conclusion
Les GMM sont particulièrement utiles lorsqu'il s'agit de distributions de données complexes, d'ensembles de données hétérogènes ou de tâches impliquant une estimation de densité. Ils offrent une flexibilité dans la modélisation et la capture de la structure sous-jacente des données, ce qui en fait des outils précieux dans diverses tâches d'apprentissage automatique et d'analyse de données.