10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

Pembuka

Assalamu'alaikum warahmatullahi wabarakatuh. Puji syukur kehadirat Allah Subhana Wata'ala atas limpahan
Rahmat dan HidayahNya kepada kita semua. Sholawat serta salam senantiasa tercurah limpahkan kepada
baginda Muhammad Rasulullah Salallahualaihiwassalam.

Halo para Pejuang Data. Selamat berjumpa di pertemuan kesembilan Program Training Algoritma Machine
Learning Kelas Mahir.

Pada pertemuan ini kamu akan belajar:

K Means Clustering
Algoritma K Means Clustering
Contoh K Means Clustering
Fungsi K Means Clustering
K Means Clustering dengan Scikit Learn

K Means Clustering

K-means (MacQueen, 1967) adalah salah satu algoritma pembelajaran tanpa pengawasan paling sederhana
yang memecahkan masalah pengelompokan yang terkenal. Prosedurnya mengikuti cara sederhana dan
mudah untuk mengklasifikasikan kumpulan data yang diberikan melalui sejumlah cluster tertentu (asumsikan k
cluster) tetap secara apriori. Ide utamanya adalah mendefinisikan k centroid, satu untuk setiap cluster. Centroid
ini harus ditempatkan dengan cara yang licik karena lokasi yang berbeda menyebabkan hasil yang berbeda.
Jadi, pilihan yang lebih baik adalah menempatkan mereka sejauh mungkin dari satu sama lain. Langkah
selanjutnya adalah mengambil setiap titik milik kumpulan data yang diberikan dan mengaitkannya ke centroid
terdekat. Ketika tidak ada poin yang tertunda, langkah pertama selesai dan pengelompokan awal dilakukan.
Pada titik ini kita perlu menghitung ulang k centroid baru sebagai barycenter dari cluster yang dihasilkan dari
langkah sebelumnya. Setelah kita memiliki k centroid baru ini, pengikatan baru harus dilakukan antara titik set
data yang sama dan centroid baru terdekat. Sebuah loop telah dibuat. Sebagai hasil dari loop ini kita dapat
melihat bahwa k centroid mengubah lokasinya langkah demi langkah sampai tidak ada lagi perubahan yang
dilakukan. Dengan kata lain centroid tidak bergerak lagi. Terakhir, algoritma ini bertujuan untuk meminimalkan
fungsi tujuan, dalam hal ini fungsi kesalahan kuadrat. Fungsi tujuan

𝑘 𝑛
𝐽 = ∑ ∑ ‖ 𝑥𝑖(𝑗) − 𝑐𝑗 ‖2
𝑗=1 𝑖=1
di mana ‖ 𝑥(𝑗)𝑖 − 𝑐𝑗 ‖2 adalah ukuran jarak yang dipilih antara titik data 𝑥(𝑗)𝑖 dan pusat cluster 𝑐𝑗 , merupakan
indikator jarak n titik data dari masing-masing pusat cluster.

Algoritma K-Means Clustering

1. Tentukan parameter k
2. Tentukan pusat cluster awal secara acak
3. Hitung jarak setiap data ke pusat cluster
4. Tetapkan cluster data berdasarkan pusat cluster terdekat
5. Memperbarui pusat cluster dengan menghitung nilai rata-rata setiap cluster

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 1/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

6. Ulangi langkah 3-5 sampai kriteria berhenti terpenuhi:

A. Jumlah iterasi tertentu tercapai, ATAU
B. Tidak ada (atau minimal) perbedaan anggota cluster pada dua iterasi terakhir, OR
C. Tidak ada (atau minimum) perbedaan pusat cluster, ATAU
D. Selisih SSE (Sum of Squared Error) minimum

Contoh Implementasi K Means

0. Dataset

𝑥1 𝑥2
1 1

2 3

7 8

8 8

In [1]:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt

In [2]:

data=pd.DataFrame({"x1":[1,2,7,8], "x2":[1,3,8,8]})
data

Out[2]:

x1 x2

0 1 1

1 2 3

2 7 8

3 8 8

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 2/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [3]:

plt.scatter(data.x1, data.x2)

Out[3]:

<matplotlib.collections.PathCollection at 0x2cce5022460>

1. Tentukan parameternya 𝑘
𝑘=2
In [4]:

k=2

2. Tentukan pusat cluster awal secara acak

Centroid 𝑥1 𝑥2
𝑐1 1 1

𝑐2 2 3

In [5]:

pusat_klaster = np.array([[1,1],[2,3]])
pusat_klaster

Out[5]:

array([[1, 1],
[2, 3]])

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 3/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [6]:

# Determine the initial cluster center randomly

import random
def pusat_klaster_awal(k, data):
X=np.array(data)
n=len(X)
list_1=np.arange(0,n)
pusat_klaster_index = random.choices(list_1, k=k)
pusat_klaster=X[pusat_klaster_index]
return pusat_klaster

3. Hitung jarak setiap data ke pusat cluster

In [7]:

# Define the euclidean distance function

def jarak_euclidean(x,y):
return np.sqrt(sum(pow(a-b, 2) for a, b in zip(x,y)))

In [8]:

def jarak_centroid_euclidean(data,pusat_klaster):
n=len(data)
k=np.array(pusat_klaster).shape[0]
jarak=[]
for i in range(n):
x = list(data.iloc[i,::])
jrk = [jarak_euclidean(x, pusat_klaster[j]) for j in range(k)]
jarak.append(jrk)
return jarak

In [9]:

jarak_centroid=jarak_centroid_euclidean(data,pusat_klaster)
jarak_centroid

Out[9]:

[[0.0, 2.23606797749979],
[2.23606797749979, 0.0],
[9.219544457292887, 7.0710678118654755],
[9.899494936611665, 7.810249675906654]]

4. Tetapkan klaster data berdasarkan pusat klaster terdekat

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 4/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [10]:

def menentukan_klaster(jarak_centroid):
n=len(jarak_centroid)
label_klaster=list()
for i in range(n):
max_val, idx = min((val, idx) for (idx, val) in enumerate(jarak_centroid[i]))
label_klaster.append(idx)
return label_klaster

In [11]:

klaster=menentukan_klaster(jarak_centroid)
klaster

Out[11]:

[0, 1, 1, 1]

5. Memperbarui pusat cluster dengan menghitung nilai rata-rata setiap cluster

In [12]:

def menghitung_pusat_klaster(data, klaster):

data['label']=klaster
pusat_barudf=data.groupby('label', as_index=False).mean()
pusat_barudf=pusat_barudf.iloc[::,1:]
pusat_klaster_baru=np.array(pusat_barudf)
return pusat_klaster_baru

In [13]:

pusat_klaster_baru=menghitung_pusat_klaster(data, klaster)
pusat_klaster_baru

Out[13]:

array([[1. , 1. ],
[5.66666667, 6.33333333]])

6. Ulangi langkah 2 - 5 hingga kriteria henti dipenuhi:

In [14]:

def perubahan_pusat_klaster_euclidean(pusat_klaster_lama, pusat_klaster_baru):

perubahan = 0
for a,b in zip(pusat_klaster_lama, pusat_klaster_baru):
perubahan+=jarak_euclidean(a,b)
return perubahan

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 5/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [15]:

perubahan_pusat_klaster_euclidean(pusat_klaster, pusat_klaster_baru)

Out[15]:

4.955356249106169

Fungsi K Means Clustering

In [16]:

def plot_klaster(X, klaster, pusat_klaster):

df = pd.DataFrame(dict(x=X[:,0], y=X[:,1], label=klaster))
colors = {0:'blue', 1:'orange', 2:'green'}
fig, ax = plt.subplots(figsize=(8, 8))
grouped = df.groupby('label')
for key, group in grouped:
group.plot(ax=ax, kind='scatter', x='x', y='y', label=key, color=colors[key])
ax.scatter(pusat_klaster[:, 0], pusat_klaster[:, 1], marker='*', s=150, c='#ff2222')
plt.xlabel('X_1')
plt.ylabel('X_2')
plt.show()

In [17]:

def k_means(k, df):

X=np.array(df)
pusat_klaster_lama = pusat_klaster_awal(k, X)
klaster = [0]*len(X)
epsilon = 100
iterasi = -1
while epsilon>.001:
jarak_ke_pusat_klaster=jarak_centroid_euclidean(df,pusat_klaster_lama)
klaster = menentukan_klaster(jarak_ke_pusat_klaster)
plot_klaster(X, klaster, pusat_klaster_lama)
pusat_klaster_baru = menghitung_pusat_klaster(df, klaster)
epsilon = perubahan_pusat_klaster_euclidean(pusat_klaster_lama, pusat_klaster_baru)
pusat_klaster_lama = pusat_klaster_baru
iterasi += 1
return iterasi, klaster, pusat_klaster_baru

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 6/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [18]:

iterasi, klaster, pusat_klaster= k_means(2, data)

In [19]:

pusat_klaster

Out[19]:

array([[7.5, 8. ],
[1.5, 2. ]])

K-Means Clustering menggunakan Python Scikit Learn

In [20]:

from sklearn.cluster import KMeans

import numpy as np

data=pd.DataFrame({"x1":[1,2,7,8], "x2":[1,3,8,8]})

X=np.array(data)
X

Out[20]:

array([[1, 1],
[2, 3],
[7, 8],
[8, 8]], dtype=int64)

In [21]:

kmeans = KMeans(n_clusters=2, random_state=0).fit(X)

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 7/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [22]:

kmeans.labels_

Out[22]:

array([0, 0, 1, 1])

In [23]:

kmeans.predict([[0, 0], [12, 3]])

Out[23]:

array([0, 1])

In [24]:

kmeans.cluster_centers_

Out[24]:

array([[1.5, 2. ],
[7.5, 8. ]])

Latihan

Diberikan Dataset

In [25]:

data=pd.DataFrame({"Province Name":["Jakarta", "Jawa Tengah", "Bali", "Sumatera Selatan", "

"Confirmed":[1231, 1452, 789, 201, 78, 45],
"Death":[10, 35, 8, 2, 1, 0]})
data_used=data[["Confirmed", "Death"]]
data_used

Out[25]:

Confirmed Death

0 1231 10

1 1452 35

2 789 8

3 201 2

4 78 1

5 45 0

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 8/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

In [26]:

# Cluster the dataset above using K Means clustering into 2 cluster.

iterasi, klaster, pusat_klaster= k_means(2, data_used)

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 9/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 10/11

10/22/21, 10:09 AM K_Means_Clustering - Jupyter Notebook

localhost:8888/notebooks/Pejuang Data 3.0/Training Algoritma Machine Learning/Minggu 5/Pertemuan 1/K_Means_Clustering.ipynb 11/11