無料の Python 機械学習コース 9: K 平均法クラスタリング

K-クラスタリングとはどういう意味ですか?

K-means クラスタリングは、最も人気があり、広く使用されている教師なし学習モデルです。データをクラスタリングすることで機能するため、クラスタリングとも呼ばれます。教師あり学習モデルとは異なり、教師なしモデルではラベル付きデータは使用されません。

このアルゴリズムはラベルを予測することを目的としたものではありません。データセットをより深く理解し、ラベルを付けることが重要です。

[[360705]]

k-means クラスタリングでは、データセットをさまざまなグループにクラスタ化します。

k平均法クラスタリングアルゴリズムの仕組み

（１）最初のステップは、いくつかの点をランダムに初期化することです。これらの点はクラスターの重心と呼ばれます。

上の画像では、赤と青の点がクラスターの重心です。

任意の数のクラスター重心を選択できます。ただし、クラスターの重心の数はデータ ポイントの合計数よりも少なくする必要があります。

（２）２番目のステップはクラスター割り当てステップである。このステップでは、各緑色のポイントを反復処理する必要があります。ポイントが赤いポイントに近いか青いポイントに近いかに応じて、どちらか一方に割り当てる必要があります。

つまり、緑の点は、青のクラスターの重心に近いか赤のクラスターの重心に近いかに応じて、赤または青に色付けされます。

（３）次のステップはクラスターの重心を移動することです。ここで、赤いクラスターの重心に割り当てられたすべての赤い点の平均を取り、赤いクラスターの重心をその平均に移動する必要があります。青いクラスターの重心に対しても同じことを行う必要があります。

これで、新しいクラスターの重心ができました。 2 番 (クラスター割り当て手順) に戻る必要があります。ポイントを新しいクラスターの重心に再配置する必要があります。その後3回目を繰り返します。

下の図に示すように、両方のクラスター重心が適切な位置にくるまで、手順 2 と 3 を数回繰り返す必要があります。

ご覧のとおり、すべての緑色の点を、それらに割り当てられたクラスターの重心によって単純に色分けしました。青いクラスターの重心は青いクラスターの中心にあり、赤いクラスターの重心は赤いクラスターの中心にあります。

アルゴリズムを開発していくと、これが少し明確になります。これについてはさらに詳しく議論します。

アルゴリズムの開発

このアルゴリズムに使用するデータセットは、Coursera の Andrew Ng の機械学習コースから取得しました。以下は、k-means アルゴリズムを開発するためのステップバイステップのガイドです。

（1）必要なパッケージとデータセットをインポートする

pandasをpdとしてインポートする
numpyをnpとしてインポートする
df1 = pd .read_excel('dataset.xlsx', sheet_name = 'ex7data2_X' ,ヘッダー=なし)
 df1.head()

データセットには 2 つの列しかありません。視覚化しやすいため、2 つの注目データセットを使用しました。視覚的に見るとアルゴリズムが理解しやすくなります。ただし、同じアルゴリズムは多次元キューブにも適用されます。

プロセス中に他の配列も処理するため、DataFrame df1 を Numpy 配列に変換します。

 X = np .array(df1)

ここで、上で説明した 3 つの手順を実行します。

（２）最初のステップは、重心をランダムに初期化することです。

データセットから 3 つのポイントをランダムに初期化します。まず、0 からデータセットの長さまでの 3 つの数字を選択します。

ランダムをインポートrandominit_centroids = random.sample(range(0, len(df1)), 3)
初期重心

出力：

 [95、30、17]

これら 3 つの数値をインデックスとして使用し、それらのインデックスのデータ ポイントを取得します。

重心= []
 init_centroids 内の i の場合:
    重心.append(df1.loc[i])
重心

出力：

 [0 3.907793
 1 5.094647
名前: 95、データ型: float64、
 0 2.660466
 1 5.196238
名前: 30、データ型: float64、
 0 3.007089
 1 4.678978
名前: 17、データ型: float64]

これら 3 つの点が初期の重心となります。

2D配列に変換しました。なぜなら、この形式の方が私にとって馴染み深いからです。

重心= np.array (重心)

出力：

配列([[3.90779317, 5.09464676],
 [2.66046572, 5.19623848],
 [3.00708934, 4.67897758]])

（３）クラスター割り当てステップを実装する。

このステップでは、データセット内のすべてのデータ ポイントを反復処理します。

データポイントはデータの行を表す

データの行を見て、このデータがどのようにクラスターに割り当てられるかを見てみましょう。

3 つの重心すべてのデータ距離を計算します。そのデータ ポイントは、最短距離の重心に割り当てられます。

ご覧のとおり、2 点間の距離を多数計算する必要があります。距離を計算する関数を開発しましょう。

 def calc_distance(X1, X2):
    （合計（（X1 - X2）** 2））** 0.5を返す

各データ ポイントを重心に割り当てる関数を開発します。 「centroids」配列には 3 つの値しかありません。したがって、0、1、2 の 3 つのインデックスがあります。各データ ポイントにこれらのインデックスの 1 つを割り当てます。

定義: findClosestCentroids(ic, X):
割り当てられた重心= []
    i が X に含まれる場合:
距離= []
        icのjの場合:
            距離.append(calc_distance(i, j))
        割り当てられた重心.append(np.argmin(距離))
    割り当てられた重心を返す

この関数は、データ ポイントをクラスターに割り当てます。この関数を使用して、各データ ポイントの重心を計算してみましょう。

 get_centroids = findClosestCentroids (重心, X)
重心を取得する

部分出力:

 [2,
 0,
 0,
 2、
 1、
 2、
 2、
 2、
 1、
 1、
 2、
 2、
 2、
 2、
 2、
 2、
 0,

総出力は非常に長いです。したがって、ここでは出力の一部を示します。出力の最初の重心は 2 です。これは、重心リストのインデックス 2 に割り当てられることを意味します。

（4）最後のステップは、データポイントの平均値に応じて重心を移動することです。

このステップでは、各重心のすべてのデータ ポイントの平均を取得し、重心をその平均に移動します。

たとえば、インデックス 2 の重心に割り当てられたすべてのポイントの平均を計算し、重心 2 を平均に移動します。インデックス 0 と 1 の重心に対しても同じ操作が実行されます。

これを実行する関数を定義しましょう:

 calc_centroids(クラスター, X):
新しい重心= []
 new_df = pd .concat([pd.DataFrame(X), pd.DataFrame(クラスター,列= ['cluster'])],
軸= 1 )
    set(new_df['cluster'])内のcの場合:
 current_cluster = new_df [new_df['cluster'] == c][new_df.columns[:-1]]
 cluster_mean = current_cluster .mean(軸= 0 )
        new_centroids.append(クラスター平均)
    new_centroidsを返す

これらはすべて開発する必要がある機能です。

先ほど説明したように、このクラスター割り当てプロセスを繰り返し、重心が適切な位置にくるまで重心を複数回移動する必要があります。

この問題では、このプロセスを 10 回繰り返すことを選択しました。これがどのように機能するかを視覚的に示せるように、各反復の後に重心とデータをプロットし続けます。

 iが範囲(10)内にある場合:
 get_centroids = findClosestCentroids (重心, X)
重心= calc_centroids (get_centroids, X)
    #print(重心)
    plt.figure()
    plt.scatter(np.array(重心)[:, 0], np.array(重心)[:, 1],色= '黒' )
    plt.scatter(X[:, 0], X[:, 1],アルファ= 0.1 )
    plt.show()

5 回の反復後、重心は最適な位置に設定されます。したがって、それ以降は立場を変えることはありません。

次元削減を試す前に、上記のコードをすべて実行して、十分に学習させることをお勧めします。

そうしないと、圧倒されてしまうかもしれません。また、アルゴリズムについては詳しく説明したので、ここでは簡単に説明します。

次元削減

このアルゴリズムの使用例を少なくとも 1 つ説明したいと思います。非常に便利な使用例の 1 つは次元削減です。

画像について考えてみましょう。画像内に異なるピクセルが多すぎる可能性があります。どのようなコンピュータービジョンの問題でも、画像のサイズを縮小できれば、デバイスはそれをはるかに速く読み取ることができるようになります。そうではありませんか?

今開発したアルゴリズムを使用して、画像のサイズを縮小できます。

これを説明するためにカエルの写真を使います:

> 著者による画像

この写真をノートブックと同じフォルダにアップロードしました。これをインポートしてみましょう:

 cv2をインポート
im = cv2.imread ('frog.png')
私は

出力：

配列([[[ 2, 57, 20],
        [2、57、20]、
        [2、57、21]、
        ...、
        [ 0, 5, 3],
        [8、12、11]、
        [ 91, 94, 93]], [[ 2, 56, 20],
        [ 1, 54, 20],
        [1, 56, 19],
        ...、
        [ 0, 2, 1],
        [7, 9, 8],
        [ 91, 92, 91]], [[ 2, 55, 20],
        [2、53、19]、
        [ 1, 54, 18],
        ...、
        [ 2, 4, 2],
        [8, 11, 9],
        [ 91, 93, 91]], ..., [[ 6, 76, 27],
        [6、77、26]、
        [6、78、28]、
        ...、
        [6、55、18]、
        [13、61、25]、
        [ 94, 125, 102]], [[ 9, 79, 31],
        [11、81、33]、
        [ 12, 82, 32],
        ...、
        [6、56、19]、
        [14、61、27]、
        [ 96, 126, 103]], [[ 43, 103, 63],
        [44、107、66]、
        [46、106、66]、
        ...、
        [37、81、50]、
        [47、88、59]、
        [118, 145, 126]]], dtype = uint8 )

配列の形状を確認します。

 im.sgape

出力：

 （155、201、3）

配列全体を 255 で割って、すべての値が 0 から 1 になるようにします。

次に、それを 155*201 x 3 に再形成して 2D 配列にします。なぜなら、2次元配列のすべての関数は以前に開発済みだからです。

 im = (im/255).reshape(155*201, 3)

上記のように、さまざまなピクセル値が存在します。これを減らして 10 ピクセルの値だけを保持します。

10個のランダムなインデックスを初期化しましょう。

ランダムrandom_index = random.sample(range(0, len(im)), 10)

ここで、前の例のように重心を見つけます。

重心= []
 random_index 内の i の場合:
    重心.append(im[i])
重心= np.array (重心)

出力：

配列([[0.00392157, 0.21176471, 0.06666667],
 [0.03529412, 0.2627451, 0.09803922],
 [0.29411765, 0.3254902, 0.26666667],
 [0.00784314, 0.18431373, 0.05882353],
 [0.29019608, 0.49411765, 0.28235294],
 [0.5254902, 0.61176471, 0.48627451],
 [0.04313725, 0.23921569, 0.09803922],
 [0.00392157, 0.23529412, 0.0745098 ],
 [0.00392157, 0.20392157, 0.04705882],
 [0.22352941, 0.48235294, 0.40784314]])

さて、「im」も配列に変換します。

 im = np.array (im)

データは準備完了です。これで、クラスタリング プロセスに進むことができます。しかし今回は視覚化は行いません。データがもはや 2 次元ではないためです。したがって、視覚化は容易ではありません。

 iが範囲(20)内にある場合:
 get_centroids = findClosestCentroids (重心、im)
重心= calc_centroids (get_centroids, im)

これで重心が更新されました。

重心

出力：

 [0 0.017726
 1 0.227360
 2 0.084389
データ型: float64,
 0 0.119791
 1 0.385882
 2 0.247633
データ型: float64,
 0 0.155117
 1 0.492051
 2 0.331497
データ型: float64,
 0 0.006217
 1 0.048596
 2 0.019410
データ型: float64,
 0 0.258289
 1 0.553290
 2 0.406759
データ型: float64,
 0 0.728167
 1 0.764610
 2 0.689944
データ型: float64,
 0 0.073519
 1 0.318513
 2 0.170943
データ型: float64,
 0 0.035116
 1 0.273665
 2 0.114766
データ型: float64,
 0 0.010810
 1 0.144621
 2 0.053192
データ型: float64,
 0 0.444197
 1 0.617780
 2 0.513234
データ型: float64]

これが最後のステップです。これら 10 点のみを保持します。

get_centroids も印刷すると、クラスターの割り当てが表示されます。

ここで、配列 'im' 全体を反復処理し、データを対応するクラスター重心値に変更します。こうすることで、これらの重心値のみが得られます。

元の配列を変更するのではなく、コピーを作成してそこで変更を加えたいと思います。

 im im_recovered = im.copy()
 iが範囲内(len(im))の場合:
    im_recovered[i] = 重心[get_centroids[i]]

最初に画像のサイズを変更して 2 次元配列にしたことを覚えています。今度はそれを元の形に戻す必要があります。

 im_recovered im_recovered = im_recovered.reshape(155, 201, 3)

ここでは、違いを示すために、元の画像と縮小した画像を並べてプロットしています。

 im1 = cv2.imread ('frog.png')
 matplotlib.image を mpimg としてインポートします。
図、 ax = plt.subplots (1,2)
 ax[0].imshow(im1)
 ax[1].imshow(im_recovered)

> 著者による画像

ご覧のとおり、画像のサイズが大幅に縮小されました。カエルみたいですね！でもコンピューターの方がずっと速く読み取れますよ！

結論は

この記事では、k-means クラスタリングの仕組みと、k-means クラスタリング アルゴリズムをゼロから開発する方法について説明しました。このアルゴリズムを使用して画像サイズを縮小する方法についても説明しました。別の画像を試してください。

この記事で使用したデータセットへのリンクはこちらです。

https://github.com/rashida048/Machine-Learning-With-Python/blob/master/kmean.xlsx

コードは次のとおりです:

https://github.com/rashida048/Machine-Learning-With-Python/blob/master/k_mean_clustering_final.ipynb