Para la agrupación jerárquica de datos categóricos, los métodos de medición de distancia comúnmente utilizados se basan en el coeficiente de coincidencia, el coeficiente de similitud de Jaccard o el coeficiente de similitud del coseno. A continuación se proporciona un agrupamiento jerárquico basado en coincidencias.
de abajo hacia arriba
La idea básica de la implementación de este código es la siguiente:
- Inicialice cada muestra como un grupo.
- Calcule la diferencia entre cada par de conglomerados, utilizando aquí el coeficiente de coincidencia simple.
- Encuentre el par de conglomerados con la mayor disimilitud.
- Combinar el par de clústeres más diferentes.
- Repita los pasos 3 y 4 hasta que solo queden k grupos.
def match_hierarchy_clustering(X, K):
n_samples, n_features = X.shape
# 初始化簇
clusters = [[i] for i in range(n_samples)]
# 计算相异度矩阵
S = np.zeros((n_samples, n_samples))
for i in range(n_samples):
for j in range(i + 1, n_samples):
matches = np.sum(X[i, :] == X[j, :])
S[i, j] = matches / n_features
S[j, i] = matches / n_features
# 循环合并簇，直到只剩 K 个簇
while len(clusters) > K:
# 找到相异度最大的一对簇
max_sim = -1
max_i, max_j = -1, -1
for i in range(len(clusters)):
for j in range(i + 1, len(clusters)):
sim = 0
for k in clusters[i]:
for L in clusters[j]:
sim += S[k, L]
sim /= len(clusters[i]) * len(clusters[j])
if sim > max_sim:
max_sim = sim
max_i = i
max_j = j
# 合并相异度最大的一对簇
clusters[max_i].extend(clusters[max_j])
del clusters[max_j]
print("clusters")
print(clusters)
# 计算每个簇的聚类中心
centroids = []
for cluster in clusters:
if len(cluster) == 2:
r = random.choice(cluster)
centroid = X[r, :]
else:
centroid = []
for dd in range(n_features):
centroid.append(stats.mode(X[cluster, dd])[0][0])
centroid = np.array(centroid)
centroids.append(centroid.astype(int))
return np.array(centroids)Algoritmo DIANA de arriba hacia abajo
El algoritmo DIANA (Divisive Analysis) es un algoritmo de agrupamiento jerárquico de arriba hacia abajo (Top-Down) Su idea principal es comenzar a partir de un gran grupo que contiene todas las muestras y dividirlo gradualmente en subgrupos cada vez más pequeños. Los pasos son los siguientes:
-
Inicialización: trate todas las muestras como un grupo grande.
-
Calcular la disimilitud: Calcule la disimilitud entre cada muestra y otras muestras, utilizando la distancia euclidiana, la distancia de Manhattan, la similitud del coseno, etc.
-
Seleccione el clúster con la mayor disimilitud: busque el clúster actual con la mayor disimilitud y divídalo en dos subclústeres.
-
Calcule la disimilitud de los subclústeres: para los dos subclústeres recién generados, vuelva a calcular la disimilitud entre ellos y otros clústeres.
-
Repita los pasos 3 y 4 hasta que todos los grupos tengan el tamaño 1.
-
Agrupamiento jerárquico: De acuerdo con la jerarquía de clúster resultante, los clústeres se organizan en una estructura de árbol (árbol de clúster).
-
Agrupación utilizando el árbol de clústeres: comenzando desde la parte superior del árbol, de acuerdo con la disimilitud entre los clústeres, los clústeres se fusionan gradualmente en clústeres más grandes hasta que se alcanza el número predeterminado de clústeres o se alcanza un cierto umbral de disimilitud.
Cabe señalar que el algoritmo DIANA es un algoritmo voraz, que solo considera el clúster con mayor disimilitud en el momento actual, en lugar del óptimo global. Por lo tanto, puede quedarse atascado en una solución óptima local y no obtener una solución óptima global. Además, la complejidad computacional del algoritmo DIANA es alta, porque cada división requiere volver a calcular la disimilitud entre todas las muestras.
def diana_clustering(X, k):
"""
对分类数据进行 DIANA 聚类
参数：
X -- 二维的 numpy 数组，每一行表示一个样本，每一列表示一个特征
k -- 聚类的簇数
返回：
clusters -- 一个列表，其中的每个元素是一个列表，表示一个簇
centroids -- 一个二维的 numpy 数组，每一行表示一个聚类中心
"""
n_samples, n_features = X.shape
# 初始化簇
clusters = [[i] for i in range(n_samples)]
# 计算相异度矩阵
S = np.zeros((n_samples, n_samples))
for i in range(n_samples):
for j in range(i + 1, n_samples):
matches = np.sum(X[i, :] == X[j, :])
S[i, j] = matches / n_features
S[j, i] = matches / n_features
# 循环合并簇，直到只剩 k 个簇
while len(clusters) > k:
# 找到相异度最大的簇
max_sim = -1
max_cluster = None
for cluster in clusters:
sim = np.mean(S[cluster][:, cluster])
if sim > max_sim:
max_sim = sim
max_cluster = cluster
# 计算簇内相异度矩阵
S_cluster = S[max_cluster][:, max_cluster]
# 找到相异度最大的一对样本
i, j = np.unravel_index(np.argmax(S_cluster), S_cluster.shape)
# 将相异度最大的一对样本分别分配到不同的簇
new_cluster_1 = [max_cluster[i]]
new_cluster_2 = [max_cluster[j]]
for index in range(len(max_cluster)):
if index not in [i, j]:
if S_cluster[index, i] > S_cluster[index, j]:
new_cluster_1.append(max_cluster[index])
else:
new_cluster_2.append(max_cluster[index])
# 更新簇列表
clusters.remove(max_cluster)
clusters.append(new_cluster_1)
clusters.append(new_cluster_2)
# 计算聚类中心
centroids = np.zeros((k, n_features))
for i, cluster in enumerate(clusters):
if len(cluster) == 2:
centroids[i] = np.mean(X[cluster], axis=0)
else:
for dd in range(n_features):
centroids[i][dd] = stats.mode(X[cluster, dd])[0][0]
return centroidsotro:
¿Qué debo hacer si un determinado clúster tiene solo un valor en el proceso de agrupación jerárquica?
-
Aumentar la cantidad de datos: aumentar la cantidad de datos puede reducir la probabilidad de que solo haya una muestra en el conglomerado.
-
Elija un método de medición de similitud adecuado: seleccionar un método de medición de similitud adecuado para el tipo de datos puede aumentar la similitud de las muestras en el conglomerado, lo que reduce la probabilidad de que solo haya una muestra en el conglomerado.
-
Ajuste los parámetros del algoritmo de agrupamiento: por ejemplo, puede ajustar la cantidad de agrupamientos, umbrales y otros parámetros en el proceso de agrupamiento para obtener resultados de agrupamiento más razonables.
-
Combinación con otros métodos de agrupamiento: el agrupamiento jerárquico se puede combinar con otros métodos de agrupamiento, como el algoritmo K-Means, etc., para obtener mejores resultados de agrupamiento.