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

[実行結果]

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

k-meansでクラスタリング

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

品種ごとに３つに分類したいのでクラスタ数は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では２つに分類されて実際の分類とはだいぶ違う結果となりました。

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

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

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

[実行結果]

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

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

k-meansでクラスタリング

クラスタ数を２に設定して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でクラスタリング

今度は、クラスタ数を同じく２に設定して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のアヤメのデータセットを読み込みます。

比較しやすくするために、サンプル数を１０分の１に減らします。(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()

[実行結果]

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

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

Python × AI - 階層クラスタリング（最長距離法）

今回は最長距離法を使ってクラスタリングをします。

最長距離法は完全リンク法（complete_linkage）と呼ばれることもあり、各クラスタにおいて一番遠い点同士の距離をクラスタの距離とする方法です。

データセットの準備

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

比較しやすくするために、サンプル数を１０分の１に減らします。(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に“complete”を指定(1行目)し、ウォード法では“ward”を指定(7行目)します。

[Google Colaboratory]

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

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

[実行結果]

クラスタ数３として比較すると、まとまっている位置が変わっていますが同じように分類されているようです。

最長距離法は計算量が少なく、分類感度も比較的高いですが、拡散現象が生じることがあります。

拡散現象とはクラスターが大きくなるにつれ、他のデータと最長距離を多く持つようになり、次のクラスターの形成の候補に選ばれにくくなる現象です。

Python × AI - 階層クラスタリング（最短距離法）

前回までは、ウォード法でクラスタリングを行ってきましたが、今回は最短距離法を使ってクラスタリングをします。

データセットの準備

まずscikit-learnのアヤメのデータセットを読み込みます。

比較しやすくするために、サンプル数を１０分の１に減らします。(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に“single”を指定(1行目)し、ウォード法では“ward”を指定(7行目)します。

[Google Colaboratory]

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

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

[実行結果]

結果はほとんど変わっていないようですが、5,13,7,11の分類が少し異なっています。

最短距離法のメリットは計算量が少ないことです。

ただ鎖効果（ある１つのクラスタに対象が１つずつ順番に吸収されながらクラスタが形成されること）のために、クラスタが帯状になり分類感度が低いことがデメリットになります。

Python × AI - 樹形図(デンドログラム)

樹形図(デンドログラム)の表示

前回実行した階層クラスタリングの結果を、樹形図(デンドログラム)に表示します。

[Google Colaboratory]

1
2
3
4
5
from scipy.cluster.hierarchy import dendrogram
import matplotlib.pyplot as plt
fig2, ax2 = plt.subplots(figsize=(20,5))
ax2 = dendrogram(Z)
fig2.show()

[実行結果]

2,3,4,0,1が１つのクラスタにまとまっていたり、10,12,14がまとまっていたり、5,9がまとまっていることなどが分かります。

クラスタ数を指定

fcluster関数を使うと、何番のデータがどのクラスタに所属するのかを確認することができます。

パラメータcriterionに“maxclust”を指定し、クラスタ数が3の場合の、各データの所属データを確認します。

[Google Colaboratory]

1
2
3
4
from scipy.cluster.hierarchy import fcluster
clusters = fcluster(Z, t=3, criterion="maxclust")
for i, c in enumerate(clusters):
    print(i, c)

[実行結果]

樹形図の通りに３グループに分かれていることが確認できました。

距離を指定

次は、パラメータcriterionに“distance”を指定し、距離で閾値を指定してみます。

樹形図に横線を引いてその位置で分けるようなイメージになります。

樹形図の縦軸に表示されている数値が各点の距離になります。

距離（縦軸に対応）に1.6を指定して実行してみます。

[Google Colaboratory]

1
2
3
clusters1 = fcluster(Z, 1.6, criterion="distance")
for i, c in enumerate(clusters1):
    print(i, c)

[実行結果]

今度はクラスタ数4に分かれることが確認できました。

樹形図をみると、縦軸の8から横線を引くとクラスタ数が2に、縦軸の3から横線を引くとクラスタ数が3に、縦軸の1.6から横線を引くとクラスタ数が4になることが一目瞭然に確認できますね。

Python × AI - 階層クラスタリング(ウォード法)

階層クラスタリングは、これまでの非階層クラスタリングとは違い最も距離が近くて似ている（類似度が高い）組み合わせからまとめていく方法です。

結果として出力される樹形図から、分類の過程でできるクラスタがどのように結合されていくかをひとつずつ確認できるため、最適なクラスタ数を後から決めることができます。

樹形図で視覚的に解釈がしやすいというメリットがある反面、非階層クラスタリングよりも計算量が多くなる傾向があるので結果がでるまでに時間がかかることがあります。

データセットの準備

階層クラスタリング用のデータセットを準備します。

まずscikit-learnのアヤメのデータセットを読み込みます。

解釈がしやすくなるようにサンプル数を１０分の１に減らし、４つある説明変数も２つに減らします。(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, 2:4]
fig = plt.figure(figsize=(6, 6))
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()

[実行結果]

散布図に表示されている番号は、樹形図に出てくる番号に対応します。

（樹形図は次回表示します。）

階層クラスタリングの実行

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

4行目のmethodには、ウォード法(ward)を設定しています。

ウォード法(ward)は、あるクラスタ同士が結合すると仮定したとき、結合後の全てのクラスタにおいて、クラスタの重心とクラスタ内の各点の距離の２乗和の合計が最小となるようにクラスタを結合させていく方法です。

同じく4行目のmetricには元のデータの点と点の距離の定義で、今回はユークリッド距離(euclidean)を指定しています。

ユークリッド距離とは、2点間の直線距離のことです。

[Google Colaboratory]

1
2
3
4
5
import pandas as pd
from scipy.cluster.hierarchy import linkage

Z = linkage(X, method="ward", metric="euclidean")
pd.DataFrame(Z)

[実行結果]

結果に出力したデータフレームZの意味は次の通りです。

  • １～２列目
    結合されたクラスタの番号
  • ３列目
    クラスタ間の距離
  • ４列目
    結合後に新しくできたクラスタの中に入っている元のデータの数

次回は、今回の結果を樹形図に表示します。

Python × AI [最適なクラスタ数を探索] - シルエット分析

シルエット分析という方法で、最適なクラスタ数を探索してみます。

シルエット分析では次のような定義で適切なクラスタを推定します。

  • クラスタ内は密になっているほど良い。
  • 各クラスタは遠くに離れているほど良い。

シルエット分析はk-means以外のクラスタリング・アルゴリズムにも適応できます。

シルエット係数

前回のクラスタリング結果に対して、シルエット係数を算出します。

sklearnのライブラリを利用します。

[Google Colaboratory]

1
2
3
4
5
6
7
import numpy as np
from matplotlib import cm
from sklearn.metrics import silhouette_samples

cluster_labels = np.unique(z_km.labels_)
n_clusters = cluster_labels.shape[0]
silhouette_vals = silhouette_samples(X, z_km.labels_)

n_clustersはラベルから取得したクラスタ数3を設定しています。(6行目)

silhouette_samplesにデータとラベルをすることで、シルエット係数を取得することができます。(7行目)

シルエット図

シルエット図を作成するコードは以下の通りです。

シルエット図は全てのサンプルを横向き棒グラフに表示したものになります。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
y_ax_lower,y_ax_upper = 0,0
yticks = []

for i,c in enumerate(cluster_labels):
  c_silhouette_vals = silhouette_vals[z_km.labels_==c]
  print(len(c_silhouette_vals))
  c_silhouette_vals.sort()
  y_ax_upper += len(c_silhouette_vals)
  color = cm.jet(float(i)/n_clusters)
  plt.barh(range(y_ax_lower,y_ax_upper),
           c_silhouette_vals,
           height = 1.0,
           edgecolor = "none",
           color = color)
  yticks.append((y_ax_lower+y_ax_upper)/2.)
  y_ax_lower += len(c_silhouette_vals)

silhouette_avg = np.mean(silhouette_vals)
plt.axvline(silhouette_avg,color = "red",linestyle = "--")
plt.ylabel("Cluster")
plt.xlabel("Silhouette Coefficient")
plt.yticks(yticks,cluster_labels + 1)

適切にクラスタリングできていれば、各クラスタのシルエットの厚さが均等に近くなります。

シルエット係数は、-1から1の間の値をとり次のような意味になります。

  • 1に近いほど、そのクラスタは他のクラスタから遠く離れていることを表す。
    ⇒うまくクラスタ分離できている
  • 0に近いほど、隣接するクラスタと接近または隣接するクラスタと重なっていることを表す。
    ⇒クラスタの分離ができていない
  • マイナスの場合は、クラスタ化されたサンプルは誤ったクラスタに所属している可能性あり。
  • シルエットの厚さは、所属するサンプル数を表す。

[実行結果]

上記のシルエット図より、クラスタ数3でうまくクラスタリングができていることが分かります。

クラスタ数を2に変更

クラスタ数を2に変更(1行目)して散布図を描いてみます。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
km = KMeans(n_clusters=2,
            n_init=10,
            max_iter=300,
            random_state=0)
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

[実行結果]

クラスタの中心点が、いまいちな位置になっていることが分かります。

クラスタ数2のシルエット図

クラスタ数2のシルエット図を表示します。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import numpy as np
from matplotlib import cm
from sklearn.metrics import silhouette_samples

cluster_labels=np.unique(z_km.labels_)
n_clusters=cluster_labels.shape[0]

silhouette_vals=silhouette_samples(X, z_km.labels_,metric="euclidean")

y_ax_lower,y_ax_upper=0,0
yticks=[]

for i,c in enumerate(cluster_labels):
  c_silhouette_vals=silhouette_vals[z_km.labels_==c]
  print(len(c_silhouette_vals))
  c_silhouette_vals.sort()
  y_ax_upper +=len(c_silhouette_vals)
  color=cm.jet(float(i)/n_clusters)
  plt.barh(range(y_ax_lower,y_ax_upper),
           c_silhouette_vals,
           height=1.0,
           edgecolor="none",
           color=color
          )
  yticks.append((y_ax_lower+y_ax_upper)/2.)
  y_ax_lower += len(c_silhouette_vals)

silhouette_avg=np.mean(silhouette_vals)
plt.axvline(silhouette_avg,color="red",linestyle="--")
plt.ylabel("Cluster")
plt.xlabel("Silhouette coefficient")
plt.show
plt.yticks(yticks,cluster_labels + 1)

[実行結果]

クラスタ1のシルエットが厚く、シルエット係数の平均値（赤い破線）よりもクラスタ1のほぼすべてのサンプルが下回っており、クラスタリングが上手くいっていないことが分かります。

つまりクラスタ数2よりもクラスタ数3のほうが、最適なクラスタ数だったということが導き出せます。

Python × AI [最適なクラスタ数を探索] - エルボー法

k-means法を使う際の問題点の１つは、クラスタ数を指定しなければならないことです。

今回はエルボー法という方法で最適なクラスタ数を探索していきます。

エルボー法とは

クラスタリングの性能を数値化するには、クラスタ内の残差平方和(SSE)という指標を用います。

エルボー法は、クラスタの数を変えながら残差平方和(SSE)を計算し結果を図表することで適切なクラスタ数を推定する手法です。

サンプルデータの作成と可視化

サンプルデータを作成し、可視化を行います。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
from sklearn.datasets import make_blobs
from sklearn import cluster, preprocessing
# サンプルデータの作成
X,y=make_blobs(n_samples=150,       # サンプル点の総数
               n_features=2,        # 説明変数（次元数）の指定
               centers=3,           # クラスタの個数
               cluster_std=0.5,     # クラスタ内の標準偏差
               shuffle=True,        # サンプルをシャッフル
               random_state=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.show

[実行結果]

３つのグループに分かれたデータを作成することができました。

残差平方和(SSE)を算出

k-meansにてクラスタ数を1から10までのループし残差平方和(SSE)=km.inertia_を算出しリストに格納します。

残差平方和(SSE)が小さいほど歪みのない良いモデル（クラスタリングがうまくいっているモデル）ということになります。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
distortions = []
for i  in range(1,11): 
    km = KMeans(n_clusters=i,
                n_init=10,
                max_iter=300,
                random_state=0)
    km.fit(X_norm)
    distortions.append(km.inertia_)

plt.plot(range(1,11),distortions,marker="o")
plt.xticks(range(1,11))
plt.xlabel("Number of clusters")
plt.ylabel("Distortion")
plt.show()

[実行結果]

この図がエルボー図と呼ばれます。

クラスタ数3までは、残差平方和(SSE)が減少しクラスタ数4以降はほぼ横ばいとなっています。

エルボー法では、今回のデータにおいてのクラスタ数3のように急激に変化している点を最適なクラスタ数として選択します。

最適なクラスタ数でのクラスタリング

エルボー法で最適クラスタ数と導き出された3を指定して、クラスタリングを行います。

[Google Colaboratory]

1
2
3
4
5
6
7
8
9
km = KMeans(n_clusters=3,
                n_init=10,
                max_iter=300,
                random_state=0)
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

[実行結果]

きれいに３つのクラスタ（グループ）に分類することができました。

エルボー法を用いることで、数値として根拠を持ったクラスタ数の探索が可能になることが分かりました。

ただ、かなり明確に分かれたデータでないとエルボー図はなだらかな曲線を描き最適なクラスタ数を判定するのが難しいため、万能な手法ではありません。

次回は別の方法でクラスタ数を探索していきます。

Python × AI [クラスタリング] - k-means++

k-meansのパラメータを調整してクラスタリングを実行し、結果がどうかわるかを見てみます。

k-means++

初期パラメータのinitパラメータをrandomからk-means++にしてクラスターの初期位置を変更します。(1行目)

randomの場合は、クラスターセンターがランダムに設置されますが、k-meansの場合は、初期のクラスターセンターを互いに離れた位置に配置します。

k-means++に設定することにより、より効率的で一貫性のある結果が得られるようになります。

クラスタリングを行い、グラフ化を行います。

[Google Colaboratory]

1
2
3
4
5
6
model = KMeans(n_clusters=3, random_state=0, init="k-means++")
cls_data = df_iris.copy()
model.fit(cls_data)
cluster = model.predict(cls_data)
cls_data["cluster"] = cluster
sns.pairplot(cls_data, hue="cluster")

[実行結果]

調整ランド指数(ARI)

クラスタリングした結果の調整ランド指数(ARI)を算出します。

[Google Colaboratory]

1
2
ari = "ARI: {:.2f}".format(adjusted_rand_score(iris.target, cls_data["cluster"]))
print(ari)

[実行結果]

結果は0.73と前回と同じ結果になりました。

結果は改善しませんでしたが、k-means++はランダムより収束が早いという特徴があるため、基本的にk-means++を使うことをお勧めします。

（initパラメータを指定しなければデフォルトでk-means++となります。）

クラスタ数の変更

クラスタ数を3から2に変更してみます。

クラスタリング、グラフ化、調整ランド指数の算出まで一気に実行します。

[Google Colaboratory]

1
2
3
4
5
model = KMeans(n_clusters=2, random_state=0)
cls_data = df_iris.copy()
cls_data["cluster"] = model.fit_predict(cls_data)
sns.pairplot(cls_data, hue="cluster")
print("ARI: {:.2f}".format(adjusted_rand_score(iris.target, cls_data["cluster"])))

[実行結果]

グラフに表示される色の種類から、2つのクラスタ（グループ）にまとめられたことが分かります。

調整ランド指数(ARI)は0.54と下がってしまったので、今回実施したクラスタ数2よりもクラスタ数3の方が精度が高かったことが分かります。

次回は、適切なクラスタ数を探索する方法を試してみます。