1. Home
  2. Docs
  3. Kurikulum Python – Data Science Lanjutan
  4. Materi – Pekan ke-2
  5. Scraping Analysis – KMeans

Scraping Analysis – KMeans

sumber:medium.com

Mayoritas data yang beredar atau berhasil didapatkan merupakan data mentah yang belum memiliki label. Contohnya adalah data perjalan seseorang ke kantor. Kita mungkin akan mendapatkan banyak data misalnya 500 m, 700 m, dsb. Jika kita mendapatkan data 2 Km, mungkin kita akan melabelinya sebagai jarak tempuh jauh jika melihat data sebelumnya di 500 m. Akan tetapi, jika ternyata terdapat data dengan nilai 10 Km mungkin 2 Km tadi akan menjadi label jarak tempuh sedang. Dari hal tersebut terlihat betapa data yang akan kita dapatkan merupakan data mentah yang pelabelannya bisa sangat dtentukan oleh jumlah dataset yang kita miliki. Untuk mempelejari hal tersebut maka kita membutuhkan metode Unsupervised Learning. Salah satu cara yang akan kita gunakan adalah Klustering. Kenapa? Karena dengan Klustering kita akan dapat membagi data tersebut sesuai dengan kedekatan atau kesamaan nilai atribut dari setiap data. Pada kesempatan kali ini kita akan menggunakan metode K-Means.

Apa itu metode K-Means? K-Means merupakan metode klustering yang melakukan pembagian dengan mencari nilai sentroid secara berulang dan mengevaluasi jarak geometri data dari nilai sentroid tersebut di setiap perulangan. Hal ini dilakukan hingga kita mendapatkan nilai sentroid yang lebih stabil.

langkah-langkah k-means dilakukan. Sumber : https://stanford.edu/

Misalkan kita mempunyai data seperti pada gambar (a), jika kita menentukan bahwa kita akan menggunakan 2 sentroid maka akan di tempatkan dua buah sentroid (atau bisa disebut titik pusat massa) secara random. Nanti setiap data akan ditempatkan sesuai dengan nilai kedekatan dua buah atribut (x dan y) yang mereka miliki. Setelah itu kita akan mendapatkan dua zona klustering (gambar (c)). lalu kita akan mencari dua buah sentroid lagi, tapi kali ini tidak secara random tapi melihat dari setiap zona (gambar (d)). Setelah itu dilakukan lagi penempatan untuk mendapatkan zona klustering baru (gambar (e)). Ini terus dilakukan hingga didapatkan nilai sentroid yang stabil.

Persiapan Data

Sebagai bahan latihan kita akan menggunakan data yang kita ambil menggunakan teknik web scraping. Kita akan mengambil data pokemon pada situs,

https://pokemondb.net/pokedex/all

kita kan mengambil data pokemon dengan index 1 – 200. Kenapa kita menggunakan data ini? Karena data pokemon yang masih belum memiliki label evolusi atau pembagian menurut kekuatan sehingga akan lebih mudah untuk menjadi contoh saat menggunakan klustering dengan metode K-Means.

Langkah pertama adalah melakukan import library dan pengambilan data situs secara keseluruhan.

import csv
from urllib.request import urlopen, Request
import requests
from bs4 import BeautifulSoup as bs 
import pandas as pd

alamat = "https://pokemondb.net/pokedex/all"
safeAdd = Request(alamat, headers={'User-Agent': 'Mozilla/5.0'})
html = urlopen(safeAdd)
data = bs(html, 'html.parser')

Jika kita lakukan inspeksi komponen html maka kita akan mendapatkan bahwa data tabel yang ingin kita ambil memiliki class = ‘table’ dan id = ‘pokedex’. Kita akan mengambil data dengan alur, mengambil seluruh table, mengambil setiap baris pada tabel, mengambil setiap sel pada satu row.

table = data.find("table", {"id":"pokedex"})
rows = data.findAll("tr")

row_data = []
for row in rows:
    pass

Karena kita telah menentukan bahwa kita akan berhenti pada index pokemon 200 maka ita haruslah membuat sebuah stop function. Baru setelah itu kita akan mengambil semua data baris, pada kasus ini baris ditunjukan dengan class ‘th’ dan ‘td’.

    if row.contents[1].get_text() == "201": #stop function
        break

    for item in row.findAll(["th","td"]): #gathering function
        pass

Lalu kita akan melakukan perulangan pada satu row untuk mendapatkan isi data dari setiap sel dan akan kita masukkan pada sebuah list. kode akhir kita akan menjadi,

row_data = []
for row in rows:
    cell_data = []

    if row.contents[1].get_text() == "201": #stop function
        break


    for item in row.findAll(["th","td"]): #gathering function
        cell_data.append(item.get_text())
    row_data.append(cell_data)

Langkah selanjutnya adalah kita akan menyimpan data dalam format csv dengan memanfaatkan dataframe pandas. Ini dilakukan agar setiap ingin melakukan pengolahan kita tidak perlu melakukan pengambilan dari situs web dan menjaga situs web tersebut.

df = pd.DataFrame(row_data)
df.columns = df.iloc[0]
df = df[1:]

df.to_csv('data_pokemon.csv',index=False)

Mencari Zona Klustering

Menggunakan data yang telah kita dapatkan kita akan mencoba untuk melakukan klusterisasi pada data tersebut. Sebagai contoh kali ini kita akan menggunakan metode K-Means dengan nilai K adalah 3.

Pertama kita membaca data yang dihasilkan pada bagian sebelumnya, kita akan menggunakan bantuan pandas untuk memudahkan.

data = pd.read_csv("data_pokemon.csv") 
# Preview the first 5 lines of the loaded data 
print(data.head())

Untuk melakukan klustering kita membutuhkan dua atribut yang akan menjadi basis perhitungan nilai mereka nanti. Pada kesempatan kali ini kita akan menggunakan nilai Attack dan Defense, karena menurut penulis tumbuh kembang pokemon akan berbanding lurus dengan Attack dan Defense mereka.

Sebelumnya kita akan memastikan data yang kita miliki merupakan numeric dan kita akan menambahkan kolom transformasi untuk kedua atribut tersebut. Transformasi yang akan saya gunakan adalah logaritmik. Jangan lupa untuk menambahkan library numpy pada library sebelumnya

    data["Attack"] = pd.to_numeric(data["Attack"])
    data["Defense"] = pd.to_numeric(data["Defense"])

    #menambahkan dua kolom tranformasi
    data["Alog"] = np.log(data["Attack"])
    data["Dlog"] = np.log(data["Defense"])

    print(data.head())

Setelah itu kita akan mengambil data atribut yang kita pakai dan mengubahnya ke dalam bentuk array.

    log_data = data.iloc[:, 10:12]
    print(log_data.head())
    #       Alog      Dlog
    #0  3.891820  3.891820
    #1  4.127134  4.143135
    #2  4.406719  4.418841
    #3  4.605170  4.812184
    #4  3.951244  3.761200

    # mengubahnya menjadi array
    log_array = np.array(log_data)
    print (log_array)
    #[[3.8918203  3.8918203 ]
    # [4.12713439 4.14313473]
    # [4.40671925 4.41884061]
    # [4.60517019 4.81218436]...]

Sekarang mari kita mulai untuk melakukan klustering, kita akan menggunakan library sklearn untuk itu dan library matplotlib untuk melakukan visualisasi. Tambahkan kedua library tersebut di awal.

from sklearn.cluster import KMeans
import matplotlib.pyplot as plt

kmeans = KMeans(n_clusters=3, random_state=200)
kmeans.fit(log_array)
data['kluster'] = kmeans.labels_
print(data.head())

variabel kmeans digunakan untuk menginisiasi metode kita dengan n menunjukan jumlah sentroid dan random state sebagai dasar dari pengacakan saat melakukan pengolahan data. kmeans.fit digunakan untuk meemulai melakukan pengolahan dan hasilnya disimpan kembali ke dalam dataframe awal.

Selanjutnya kita akan melakukan visualisasi agar dapat melihat data kita lebih baik.

plt.scatter(data.Attack, data.Defense, s = 20, c = data.kluster, marker = "o", alpha = 0.5)
plt.title("Hasil Klustering K-Means")
plt.xlabel("Atk")
plt.ylabel("Def")
plt.show()
hasil visualisasi

Mencari ‘K’

Seperti pada namanya, penentuan nilai K merupakan salah satu hal penting untuk dilakukan. Pada contoh sebelumnya kita telah terlebih dahulu menentukan nilai k yang akan kita pakai adalah 3. Pertanyaannya apakah ini merupakan nilai terbaik? untuk dapat menjawabnya kita akan menggunakan dua metode penentuan nilai k terbaik, yaitu Elbow Method dan Silhouette Method. Kita akan menggunakan data yang kita generate agar lebih mudah membayangkan.

Sekarang mari kita persiapkan datanya.

from sklearn.datasets import make_blobs

X, y = make_blobs(n_samples=1000, centers=3, n_features=2, shuffle=True, random_state=31)
plt.scatter(X[:, 0], X[:, 1], s = 20, marker = "o", alpha = 0.8)
plt.show()

Maka data akan terlihat seperti,

hasil visualisasi

Elbow Method

Elbow Method menggunakan apa yang dinamakan kuadrat jarak, dimana jarak yang dimaksud disni adalah jarak antar titik dengan pusat klusternya dimana nanti ini akan dijumlahkan dan dinamakan WSS (Within-Cluster-Sum of Squared). Nilai K terbaik didapatkan dimana nilai WSS sudah mulai stabil, atau saat membentuk ‘siku’.

sse = []
k_list = []
for k in range(1, 11):
    kmeans = KMeans(n_clusters = k).fit(X)
    centroids = kmeans.cluster_centers_
    prediksi = kmeans.predict(X)
    nilai_sse = 0
    
    for i in range(len(X)):
        titik_pusat = centroids[prediksi[i]]
        nilai_sse += (X[i, 0] - titik_pusat[0]) ** 2 + (X[i, 1] - titik_pusat[1]) ** 2
    
    sse.append(nilai_sse)
    k_list.append(k)

Lalu kita lakukan plot,

    plt.plot(k_list,sse)
    plt.show()
hasil plot

Dari Plot tersebut kita mengetahui nilai terbaik adalah nilai k = 3 , dimana dari data sebelumnya ini terbukti. Akan tetapi, tidak setiap waktu kita dapat dengan jelas melihat dimana keberadaan titik belok dari plot. Pada saat itulah kita akan menggunakan metode lain.

Silhouette Method

Silhouette Method menggunakan nilai koefisien yang dihitung dari seberapa dekat relasi antara objek dalam sebuah cluster, dan seberapa jauh sebuah cluster terpisah dengan cluster lain. persamaan yang digunakan adalah,

Koefisien Silhouette = (x-y)/ max(x,y)

Dimana x adalah jarak dengan kluster lain dan y adalah jarak relasi antar objek pada kluster yang sama. Nilai K optimum didapatkan dari nilai puncak plot K terhadap Koefisien Silhouette

Kita akan membutuhkan modul tambahan dari sklearn untuk menggunakan metode ini.

from sklearn.metrics import silhouette_score

data = []
k_list = []

for k in range(2, 11):
    kmeans = KMeans(n_clusters = k).fit(X)
    labels = kmeans.labels_
    data.append(silhouette_score(X, labels, metric = 'euclidean'))
    k_list.append(k)

plt.plot(k_list,data)
plt.show()

Maka akan didapatkan hasil,

hasil visualisasi

Dari hasil tersebut kita dapat melihat bahwa nilai puncak berada pada nilai K = 3 dan ini sesuai dengan data yang kita miliki.

Sumber bacaan:

https://scikit-learn.org/stable/modules/clustering.html#k-means

https://medium.com/@16611129/memahami-k-mean-clustering-pada-machine-learning-dengan-phyton-430323d80868

[/passster]