Python × AI - クラスタリング(HDBSCAN)

HDBSCANを使ってクラスタリングを行います。

HDBSCANは、DBSCANを階層型クラスタリングのアルゴリズムに変換したもので、階層DBSCAN(Hierarchical DBSCAN)と呼ばれることもあります。

密度でグループを作成し、そのグループを距離に基づいて順次まとめていきます。

ライブラリのインストールとデータ生成

まずHDBSCANのライブラリをインストールします。(1行目)

2行目以降でデータ生成を行います。

密度の異なる3つの塊データを作成しています。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
!pip install hdbscan 
centers = [[1, 0.5], [2, 2], [1, -1]]
stds = [0.1, 0.4, 0.2]
X = datasets.make_blobs(n_samples=1000, centers=centers, cluster_std=stds, random_state=0)[0]
x = X[:,0]
y = X[:,1]
plt.figure(figsize=(10,7))
plt.scatter(x, y)
plt.suptitle("blob")
plt.show

[実行結果]

クラスタリング

比較のため、HDBSCAN(1~7行目)とDBSCAN(9~16行目)でクラスタリングを行います。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print("\nDBSCAN")
dbscan = cluster.DBSCAN(eps=0.2, min_samples=10, metric="euclidean")
labels = dbscan.fit_predict(X)
df_dbscan = pd.DataFrame(X)
df_dbscan["cluster"] = labels
df_dbscan.columns = ["axis_0","axis_1","cluster"]
display(df_dbscan["cluster"].value_counts().sort_index())

import hdbscan
print("\nHDBSCAN")
hdbscan_ = hdbscan.HDBSCAN()
hdbscan_.fit(X)
df_hdbscan = pd.DataFrame(X)
df_hdbscan["cluster"] = hdbscan_.labels_
df_hdbscan.columns = ["axis_0","axis_1","cluster"]
display(df_hdbscan["cluster"].value_counts().sort_index())

[実行結果]

DBSCANは外れ値(-1)が少しありますが、HDBSCANは3つに分類されています。

クラスタリング結果の可視化

各クラスタリング結果を可視化します。

[Google Colaboratory]

1
2
3
4
5
6
7
plt.figure(figsize=(10,3))
plt.suptitle("dbscan")
sns.scatterplot(x="axis_0", y="axis_1", hue="cluster", data = df_dbscan)

plt.figure(figsize=(10,3))
plt.suptitle("hdbscan")
sns.scatterplot(x="axis_0", y="axis_1", hue="cluster", data = df_hdbscan)

[実行結果]

HDBSCAN(下図)は、塊ごとの密度の違いに対応できるアルゴリズムのため、きちんと3つに分類されています。

DBSCAN(上図)は密度の低い塊はノイズになっているようです。

2つのクラスタリングの使い分けポイントとしては、塊ごとに密度が違うかどうかという点になります。

Python × AI - ノイズ確認(DBSCAN)

ノイズ確認

DBSCANでは、どのクラスタにも所属しないノイズ点(外れ値)を分離できるという特徴があります。

前回実施した塊データのクラスタリングからクラスタごとのデータ数を確認します。

各クラスタのデータ数をカウントして、クラスタ番号でソートします。

[Google Colaboratory]

1
pd.DataFrame(labels)[0].value_counts().sort_index()

[実行結果]

1列目がクラスタ番号で-1~4が付与されています。

2列目は所属クラスタのデータ数です。

ノイズはクラスタ番号が-1が付与されるので、7個のデータがノイズと分類されていることが分かります。

ノイズの可視化

続いてノイズデータの可視化を行います。

[Google Colaboratory]

1
2
3
4
5
6
7
import seaborn as sns
df_dbscan = pd.DataFrame(X)
df_dbscan["cluster"] = labels
df_dbscan.columns = ["axis_0","axis_1","cluster"]
df_dbscan.head()
plt.figure(figsize=(10,3))
sns.scatterplot(x="axis_0", y="axis_1", hue="cluster", data = df_dbscan)

[実行結果]

大きなクラスタから離れている点がクラスタラベルで-1でノイズ点となっています。

ノイズ点はクラスタリングの用途によっては除外しますが、反対に異常値として検知するために注目することもあります。

Python × AI - クラスタリング(DBSCAN)

DBSCAN(Density-Based Spatial Clustering of Applications with Noise)を使って、クラスタリングを行います。

DBSCANは、密度準拠クラスタリングのアルゴリズムを使います。

密接している点を同じグループにまとめ、低密度領域にある点をノイズ(外れ値)と判定します。

各点は自身の半径以内に点がいくつあるかでその領域をクラスタとして判断するため、クラスタ数をあらかじめ決めなくていいという長所があります。

近傍の密度がある閾値を超えている限り、クラスタを成長させ続け、半径以内にない点はノイズになります。

データセットの準備

今回は2種類のデータセットを生成します。

1つ目のデータセットとして塊データを生成し、可視化します。(1~9行目)

2つ目のデータセットとしてムーンデータを生成し、可視化します。(11~19行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
X = datasets.make_blobs(n_samples=1000, random_state=10, centers=5, cluster_std=1.2)[0]
sc = preprocessing.StandardScaler()
X_norm = sc.fit_transform(X)
x = X_norm[:,0]
y = X_norm[:,1]
plt.figure(figsize=(10,3))
plt.scatter(x,y)
plt.suptitle("blob")
plt.show

X_moon = datasets.make_moons(n_samples=1000, noise=0.05, random_state=0)[0]
sc = preprocessing.StandardScaler()
X_moon_norm = sc.fit_transform(X_moon)
x_moon = X_moon_norm[:,0]
y_moon = X_moon_norm[:,1]
plt.figure(figsize=(10,3))
plt.scatter(x_moon,y_moon)
plt.suptitle("moon")
plt.show

[実行結果]

ムーンデータをクラスタリング

まずk-meansのクラスタリング結果を可視化し(1~7行目)、その後にDBSCANでクラスタリングを行ってから同じく可視化しています(9~14行目)。

DBSCANモデルはcluster.DBSCAN関数で作成しします。(9行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
km_moon = cluster.KMeans(n_clusters=2)
z_km_moon = km_moon.fit(X_moon_norm)
plt.figure(figsize = (10,3))
plt.scatter(x_moon,y_moon, c=z_km_moon.labels_)
plt.scatter(z_km_moon.cluster_centers_[:,0],z_km_moon.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.suptitle("k-means")
plt.show

dbscan = cluster.DBSCAN(eps=0.2, min_samples=5, metric="euclidean")
labels = dbscan.fit_predict(X_moon_norm)
plt.figure(figsize=(10,3))
plt.scatter(x_moon,y_moon, c=labels)
plt.suptitle("dbscan")
plt.show

[実行結果]

k-meansではうまく分類できていませんが、DBSCANだときちんと分類されています。

塊データをクラスタリング

塊データもk-meansDBSCANでクラスタリングを行ってみます。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
km=cluster.KMeans(n_clusters=5)
z_km=km.fit(X_norm)
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0],z_km.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.suptitle("k-means")

dbscan = cluster.DBSCAN(eps=0.2, min_samples=5, metric="euclidean")
labels = dbscan.fit_predict(X_norm)
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=labels)
plt.suptitle("dbscan")
plt.show

[実行結果]

今回は両方のアルゴリズムでうまく分類できているようです。

DBSCANは、データの密度を基準とするアルゴリズムで、全データ点はコア点到達可能点ノイズ点に分類されます。

8行目のepsパラメータで決められた半径内にmin_samplesパラメータの値以上の点が集まっていれば、それをコア点であると判断します。

コア点ではないデータでも、近くにあるコア点からeps半径の中に入っているものは到達可能点であると判断します。

そのどちらにもなれなかった点はノイズ点(外れ値)として分類されます。

DBSCANにおいて、epsmin_samplesはとても重要なパラメータだということになります。

DBSCANの総括

DBSCANは球の形状を前提とせず、ノイズ分類もできて、クラスタ数の指定も必要ないクラスタリングになります。

デメリットとしては、全データ点を対象とした反復計算を実施しているため計算コストが高くリアルタイム性が求められるよな場合には不向きです。

またデータが密集しているとパラメータ調整が難しくなるという一面もあります。

Python × AI - クラスタリング(MiniBatchKMeans)

MiniBatchKMeansでのクラスタリングを実行します。

ミニバッチとは部分的にサンプリングされた入力データのことです。

ミニバッチでクラスタリングを行うことにより、計算時間を大幅に短縮することができますが、k-meansと比べると少し精度が落ちることがあります。

MiniBatchKMeansでクラスタリング

データは前回同様にワインの分類データセットを使います。

比較のため、最初にk-meansのクラスタリング結果を可視化し(1~5行目)、その後にMiniBatchKMeansでクラスタリングを行ってから同じく可視化しています(7~14行目)。

MiniBatchKMeansモデルはcluster.MiniBatchKMeans関数で作成し、batch_sizeには100を設定しています。(7行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0],z_km.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.suptitle("k-means")
plt.show

minikm = cluster.MiniBatchKMeans(n_clusters=3, batch_size=100)
z_minikm=minikm.fit(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_minikm.labels_)
plt.scatter(z_minikm.cluster_centers_[:,0],z_minikm.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.suptitle("mini-k-means")
plt.show

[実行結果]

k-meansとMiniBatchKMeansの結果は、ほぼ同じとなりました。

MiniBatchKMeansでは、全データではなくbatch_size分のデータごとにk-meansを実行し、結果を更新する手法です。

データが1万個よりも多い場合はMiniBatchKMeansを使うことが推奨されています。

GMMモデルなどの感度のよいクラスタリングは計算時間がかかってしまいますので、データが多い場合はMiniBatchKMeansの利用を検討しましょう。

Python × AI - クラスタリング(VBGMM)

変分混合ガウスモデル(VBGMM:Variational Bayesian Gaussian Mixture)でのクラスタリングを試してみます。

VBGMMは、クラスタ数が不明な場合に有効な手法です。

複数のガウス分布を仮定して、各データがどのガウス分布に所属するのかを決定してクラスタ分析を行います。

MeanShiftとは違って、ベイズ推定に基づいて確率分布を計算しながらクラスタ数や分布の形状を決定します。

VBGMMでクラスタリング

データは前前前回使用したワインの分類データセットを使います。(前前前回記事を参照)

比較のため、最初にk-meansのクラスタリング結果を可視化し(1~5行目)、その後にGMMでクラスタリングを行ってから同じく可視化しています(7~15行目)。

VBGMMモデルはmixture.BayesianGaussianMixture関数で作成し、クラスタ数の上限としてn_components10を指定しています。(8行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0],z_km.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.suptitle("k-means")
plt.show

from sklearn import mixture
vbgmm = mixture.BayesianGaussianMixture(n_components=10, random_state=0)
vbgmm=vbgmm.fit(X_norm)
labels=vbgmm.predict(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=labels)
plt.suptitle("vbgmm")
plt.show

[実行結果]

VBGMMで最適なクラスタ数を探す

VBGMMでは、weightsを参照するとクラスタごとの各データ分布を確認することができます。

縦軸がweightsで、横軸がクラスタ番号の棒グラフを作成します。(3行目)

[Google Colaboratory]

1
2
3
4
5
x_tick =np.array([1,2,3,4,5,6,7,8,9,10])
plt.figure(figsize=(10,2))
plt.bar(x_tick, vbgmm.weights_, width=0.7, tick_label=x_tick)
plt.suptitle("vbgmm_weights")
plt.show

[実行結果]

クラスタ数の上限(n_components)を10で実行しましたが、1つも分類されていないクラスタがあります。

クラスタ数の変更

グラフで見ると、だいたい3つ(クラスタ番号1~2と4と7)に分類されているので、n_componentsに3を設定して、もう一度クラスタリングを行います。(1行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
vbgmm = mixture.BayesianGaussianMixture(n_components=3, random_state=0)
vbgmm=vbgmm.fit(X_norm)
labels=vbgmm.predict(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=labels)
plt.suptitle("vbgmm")
plt.show

x_tick =np.array([1,2,3])
plt.figure(figsize=(10,2))
plt.bar(x_tick, vbgmm.weights_, width=0.7, tick_label=x_tick)
plt.suptitle("vbgmm_weights")
plt.show

[実行結果]

今回実施したように、VBGMMではweightsを確認して低い割合のクラスタがある場合は、n_componentsをさげて再度クラスタリングを行うという手順でクラスタ数を調整することが可能です。

Python × AI - クラスタリング(GMM)

混合ガウスモデル(GMM:Gaussian Mixture Model)でのクラスタリングを試してみます。

GMMは各データが、どのガウス分布に所属している確率が最も高いかを求めてラベリングを行います。

GMMでクラスタリング

データは前前回使用したワインの分類データセットを使います。(前前回記事を参照)

比較のため、最初にk-meansのクラスタリング結果を可視化し(1~5行目)、その後にGMMでクラスタリングを行ってから同じく可視化しています(7~15行目)。

GMMモデルはmixture.GaussianMixture関数で作成し、クラスタ数(n_components)には3を指定しています。(8行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
plt.figure(figsize=(10,3))
plt.scatter(x, y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0], z_km.cluster_centers_[:,1], s=250, marker="*", c="red")
plt.suptitle("k-means")
plt.show

from sklearn import mixture
gmm = mixture.GaussianMixture(n_components=3, covariance_type="full")
z_gmm = gmm.fit(X_norm)
z_gmm = z_gmm.predict(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x, y, c=z_gmm)
plt.suptitle("gmm")
plt.show

[実行結果]

k-meansGMMでのクラスタリング結果はほとんど同じように見えます。

ただk-meansでは同心円状での分類であり、GMMは傾いた楕円形の分類であるために多少の違いがあるようです。

またGMMではガウス分布を仮定するので、各データがどのクラスタに所属するのかという確率を求めることができます。

Python × AI - クラスタリング(X-means)

今回はX-meansというクラスタリングを試します。

前回試したMeanShiftと同様に、X-meansもクラスタ数を自動で設定してくれます。

X-meansは、k-meansのアルゴリズムに加えて、あるクラスタが正規分布2つで表されるのと1つで表されるのとでどちらが適切かを判定し、2つが適切な場合はクラスタ数を2つに分けるというアルゴリズムになります。

X-meansでクラスタリング

データは前回使用したワインの分類データセットを使います。(前回記事を参照)

まずx-meansライブラリをインストールします。(1行目)

クラスタ数の初期値として2を指定(5行目)していますが、適切なクラスタ数でクラスタリングを実施してくれます。

kmaxパラメータには最大クラスタ数を指定しています。(6行目)

最後にprocess関数をコールしてX-meansでクラスタリングを実行します。(7行目)

[Google Colaboratory]

1
2
3
4
5
6
7
!pip install pyclustering

from pyclustering.cluster.xmeans import xmeans
from pyclustering.cluster.center_initializer import kmeans_plusplus_initializer
xm_c = kmeans_plusplus_initializer(X_norm, 2).initialize()
xm_i = xmeans(data=X_norm, initial_centers=xm_c, kmax=20, ccore=True)
xm_i.process()

[実行結果]

クラスタリング結果の可視化

クラスタリング結果を可視化します。

[Google Colaboratory]

1
2
3
4
5
6
7
8
z_xm = np.ones(X_norm.shape[0])
for k in range(len(xm_i._xmeans__clusters)):
z_xm[xm_i._xmeans__clusters[k]] = k+1
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_xm)
centers = np.array(xm_i._xmeans__centers)
plt.scatter(centers[:,0],centers[:,1],s=250, marker="*",c="red")
plt.show

[実行結果]

クラスタ数を指定せずに、期待するクラスタ数3となっていることが確認できました。

Python × AI - クラスタリング(MeanShift)

MeanShiftを使ったクラスタリングを行います。

MeanShiftクラスタ数が分からない場合に、データをクラスタを分類する方法です。

複数のガウス分布(正規分布)を仮定して、各データがどのガウス分布に所属するのかを決定し、クラスタ分析を行います。

ワインの分類データセット

まず、オープンデータであるワインの分類データセットを準備します。

[Google Colaboratory]

1
2
3
4
df_wine_all = pd.read_csv("https://archive.ics.uci.edu/ml/machine-learning-databases/wine/wine.data", header=None)
df_wine = df_wine_all[[0,10,13]]
df_wine.columns = [u"class", u"color", u"proline"]
pd.DataFrame(df_wine)

今回はワインの品種(0列目)、色(10列目)、プロリン量(13列目)を使用します。

[実行結果(一部略)]

データセットを可視化

抽出したワインのデータセットを可視化します。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
X = df_wine[["color","proline"]]
sc = preprocessing.StandardScaler()
X_norm = sc.fit_transform(X)
x = X_norm[:,0]
y = X_norm[:,1]
z = df_wine["class"]
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z)
plt.show

[実行結果]

3品種ごとに色分けされたデータが確認できます。

k-meansでクラスタリング

k-meansでクラスタリングを行います。

品種ごとに3つに分類したいのでクラスタ数は3に設定します。

[Google Colaboratory]

1
2
3
4
5
6
7
km = cluster.KMeans(n_clusters=3)
z_km = km.fit(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0],z_km.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.show

[実行結果]

中心点から同心円状に広がって分類されていることが分かります。

MeanShiftでクラスタリング

MeanShift関数(1行目)を使って、MeanShiftでクラスタリングを行います。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
ms = cluster.MeanShift(seeds=X_norm)
ms.fit(X_norm)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
print(cluster_centers)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=labels)
plt.plot(cluster_centers[0,0], cluster_centers[0,1], marker="*",c="red", markersize=14)
plt.plot(cluster_centers[1,0], cluster_centers[1,1], marker="*",c="red", markersize=14)
plt.show

[実行結果]

MeanShiftでは2つに分類されて実際の分類とはだいぶ違う結果となりました。

MeanShiftではクラスタ数を指定しなくてもクラスタリングが実施可能なので、パラメータはseeds(乱数シード)のみ設定しています。(1行目)

MeanShiftはk-meansをベースとして近いクラスタをまとめていき、既定の距離より近くなったクラスタをまとめて1つにします。

Python × AI - クラスタリング(SpectralClustering)

今回は、SpectralClusteringでクラスタリングを行います。

SpectralClusteringはk-meansとは異なり、データ密度でクラスタを作成するため、同心円状になっていないデータもうまくクラスタリングを行うことができます。

k-meansではうまくクラスタリングできなくても、SpectralClusteringであればきちんとクラスタリングできるケースを確認していきます。

ムーンデータの生成

scikit-learnのサンプルデータセットであるムーンデータと呼ばれる三日月状のデータセットを生成します。

また、データ加工用・可視化用のライブラリもインポートしておきます。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn import cluster, preprocessing
from sklearn import datasets

X,z = datasets.make_moons(n_samples=200, noise=0.05, random_state=0)
sc = preprocessing.StandardScaler()
X_norm = sc.fit_transform(X)
display(X_norm)

[実行結果(途中略)]

ムーンデータの可視化

生成したデータを可視化します。

[Google Colaboratory]

1
2
3
4
5
x = X_norm[:,0]
y = X_norm[:,1]
plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z)
plt.show

[実行結果]

三日月の形をしたデータが上下に2つあることが分かります。

この2つにクラスタリングができれば良さそうです。

k-meansでクラスタリング

クラスタ数を2に設定してk-meansでクラスタリングを行ってみます。(1行目)

[Google Colaboratory]

1
2
3
4
5
6
7
km = cluster.KMeans(n_clusters=2)
z_km = km.fit(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_km.labels_)
plt.scatter(z_km.cluster_centers_[:,0],z_km.cluster_centers_[:,1],s=250, marker="*",c="red")
plt.show

[実行結果]

k-meansでは中心点からの距離でクラスタが決まるため、同心円状に広がっていないムーンデータではうまく分類できていないようです。

SpectralClusteringでクラスタリング

今度は、クラスタ数を同じく2に設定してSpectralClusteringでクラスタリングを行ってみます。(1行目)

パラメータのaffinity(親和性)は、クラスタリングを実施する際に作成するグラフ行列の作成法を設定します。

グラフ行列とは、「データがそれぞれどのようにつながっているか」を表す行列です。

設定している“nearest_neighbors”は、最近傍法を意味し「あるデータに対し、もっとも近いデータが属するクラスタに分類する」ことを意味します。

[Google Colaboratory]

1
2
3
4
5
6
spc=cluster.SpectralClustering(n_clusters=2, affinity="nearest_neighbors")
z_spc=spc.fit(X_norm)

plt.figure(figsize=(10,3))
plt.scatter(x,y, c=z_spc.labels_)
plt.show

[実行結果]

k-means法とは違い、データ密度でクラスタリングを作成するため、上下の三日月ごとにうまくクラスタリングできていることが分かります。

Python × AI - 階層クラスタリング(群平均法)

今回は群平均法を使ってクラスタリングをします。

群平均法は、クラスタ同士のすべての点同士の距離の平均をクラスタの距離とする方法です。

データセットの準備

前回と同様にscikit-learnのアヤメのデータセットを読み込みます。

比較しやすくするために、サンプル数を10分の1に減らします。(4行目)

最後に散布図に表示します。(10行目)

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
from sklearn.datasets import load_iris
import matplotlib.pyplot as plt

X = load_iris().data[::10]
fig = plt.figure(figsize=(6, 3))
ax = fig.add_subplot(1, 1, 1, title="iris")
plt.scatter(X[:, 0], X[:, 1])
for i, element in enumerate(X):
plt.text(element[0]+0.02, element[1] + 0.02, i)
plt.show()

[実行結果]

群平均法とウォード法の比較

群平均法とウォード法の両方でクラスタリングを行い、それぞれの樹形図を表示します。

群平均法ではパラメータmethodに“average”を指定(1行目)し、ウォード法では“ward”を指定(7行目)します。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
Z = linkage(X, method="average", metric="euclidean")
fig2, ax2 = plt.subplots(figsize=(6,3))
ax2 = dendrogram(Z)
fig2.suptitle("average")
fig2.show()

Z = linkage(X, method="ward", metric="euclidean")
fig2, ax2 = plt.subplots(figsize=(6,3))
ax2 = dendrogram(Z)
fig2.suptitle("ward")
fig2.show()

[実行結果]

距離の違いはありますが、同じクラスタリング結果となりました。

群平均法は、鎖効果や拡散現象を起こさないため、ウォード法と同様に用いられることが多い手法です。


Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×