AI dengan Python - Pembelajaran Tanpa Pengawasan: Pengelompokan
Algoritme pembelajaran mesin yang tidak diawasi tidak memiliki pengawas untuk memberikan panduan apa pun. Itulah mengapa mereka sangat selaras dengan apa yang oleh beberapa orang disebut kecerdasan buatan sejati.
Dalam pembelajaran tanpa pengawasan, tidak ada jawaban yang benar dan tidak ada guru yang membimbingnya. Algoritma perlu menemukan pola yang menarik dalam data untuk pembelajaran.
Apa itu Pengelompokan?
Pada dasarnya, ini adalah jenis metode pembelajaran tanpa pengawasan dan teknik umum untuk analisis data statistik yang digunakan di banyak bidang. Pengelompokan terutama adalah tugas membagi himpunan pengamatan menjadi himpunan bagian, yang disebut kelompok, sedemikian rupa sehingga pengamatan dalam kelompok yang sama serupa dalam satu arti dan tidak sama dengan pengamatan di kelompok lain. Dengan kata sederhana, kita dapat mengatakan bahwa tujuan utama pengelompokan adalah untuk mengelompokkan data atas dasar kesamaan dan ketidaksamaan.
Misalnya, diagram berikut menunjukkan jenis data yang serupa di cluster yang berbeda -
Algoritma untuk Mengelompokkan Data
Berikut adalah beberapa algoritma umum untuk pengelompokan data -
Algoritma K-Means
Algoritma K-means clustering merupakan salah satu algoritma yang terkenal untuk pengelompokan data. Kita perlu berasumsi bahwa jumlah cluster sudah diketahui. Ini juga disebut pengelompokan datar. Ini adalah algoritma pengelompokan berulang. Langkah-langkah yang diberikan di bawah ini perlu diikuti untuk algoritma ini -
Step 1 - Kita perlu menentukan jumlah subgrup K yang diinginkan.
Step 2- Perbaiki jumlah cluster dan tetapkan setiap titik data secara acak ke cluster. Atau dengan kata lain kita perlu mengklasifikasikan data kita berdasarkan jumlah cluster.
Pada langkah ini, sentroid cluster harus dihitung.
Karena ini adalah algoritma iteratif, kami perlu memperbarui lokasi K centroids dengan setiap iterasi sampai kami menemukan optima global atau dengan kata lain centroid mencapai lokasi optimal mereka.
Kode berikut akan membantu dalam mengimplementasikan algoritma pengelompokan K-means dengan Python. Kami akan menggunakan modul Scikit-learn.
Mari kita impor paket yang diperlukan -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
Baris kode berikut akan membantu dalam menghasilkan kumpulan data dua dimensi, yang berisi empat blob, dengan menggunakan make_blob dari sklearn.dataset paket.
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples = 500, centers = 4,
cluster_std = 0.40, random_state = 0)
Kita dapat memvisualisasikan dataset dengan menggunakan kode berikut -
plt.scatter(X[:, 0], X[:, 1], s = 50);
plt.show()
Di sini, kami menginisialisasi kmean menjadi algoritme KMeans, dengan parameter yang diperlukan berapa banyak cluster (n_clusters).
kmeans = KMeans(n_clusters = 4)
Kita perlu melatih model K-means dengan data masukan.
kmeans.fit(X)
y_kmeans = kmeans.predict(X)
plt.scatter(X[:, 0], X[:, 1], c = y_kmeans, s = 50, cmap = 'viridis')
centers = kmeans.cluster_centers_
Kode yang diberikan di bawah ini akan membantu kami memplot dan memvisualisasikan temuan mesin berdasarkan data kami, dan penyesuaian sesuai dengan jumlah cluster yang ditemukan.
plt.scatter(centers[:, 0], centers[:, 1], c = 'black', s = 200, alpha = 0.5);
plt.show()
Algoritma Pergeseran Rata-rata
Ini adalah algoritma pengelompokan populer dan kuat lainnya yang digunakan dalam pembelajaran tanpa pengawasan. Itu tidak membuat asumsi apa pun sehingga ini adalah algoritma non-parametrik. Ini juga disebut clustering hierarkis atau analisis cluster pergeseran rata-rata. Berikut ini adalah langkah-langkah dasar dari algoritma ini -
Pertama-tama, kita perlu memulai dengan titik data yang ditetapkan ke klusternya sendiri.
Sekarang, itu menghitung sentroid dan memperbarui lokasi sentroid baru.
Dengan mengulangi proses ini, kita mendekati puncak cluster, yaitu menuju wilayah dengan kepadatan lebih tinggi.
Algoritma ini berhenti pada tahap di mana sentroid tidak bergerak lagi.
Dengan bantuan kode berikut kami mengimplementasikan algoritma pengelompokan Mean Shift dengan Python. Kami akan menggunakan modul Scikit-learn.
Mari kita impor paket yang diperlukan -
import numpy as np
from sklearn.cluster import MeanShift
import matplotlib.pyplot as plt
from matplotlib import style
style.use("ggplot")
Kode berikut akan membantu dalam menghasilkan kumpulan data dua dimensi, yang berisi empat blob, dengan menggunakan make_blob dari sklearn.dataset paket.
from sklearn.datasets.samples_generator import make_blobs
Kita dapat memvisualisasikan dataset dengan kode berikut
centers = [[2,2],[4,5],[3,10]]
X, _ = make_blobs(n_samples = 500, centers = centers, cluster_std = 1)
plt.scatter(X[:,0],X[:,1])
plt.show()
Sekarang, kita perlu melatih model cluster Mean Shift dengan data masukan.
ms = MeanShift()
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
Kode berikut akan mencetak pusat cluster dan jumlah cluster yang diharapkan sesuai data input -
print(cluster_centers)
n_clusters_ = len(np.unique(labels))
print("Estimated clusters:", n_clusters_)
[[ 3.23005036 3.84771893]
[ 3.02057451 9.88928991]]
Estimated clusters: 2
Kode yang diberikan di bawah ini akan membantu memplot dan memvisualisasikan temuan mesin berdasarkan data kami, dan penyesuaian sesuai dengan jumlah cluster yang akan ditemukan.
colors = 10*['r.','g.','b.','c.','k.','y.','m.']
for i in range(len(X)):
plt.plot(X[i][0], X[i][1], colors[labels[i]], markersize = 10)
plt.scatter(cluster_centers[:,0],cluster_centers[:,1],
marker = "x",color = 'k', s = 150, linewidths = 5, zorder = 10)
plt.show()
Mengukur Kinerja Clustering
Data dunia nyata tidak secara alami diatur ke dalam sejumlah kelompok yang berbeda. Karena alasan ini, tidak mudah untuk memvisualisasikan dan menarik kesimpulan. Oleh karena itu, perlu dilakukan pengukuran kinerja clustering serta kualitasnya. Ini dapat dilakukan dengan bantuan analisis siluet.
Analisis Siluet
Metode ini dapat digunakan untuk memeriksa kualitas clustering dengan mengukur jarak antar cluster. Pada dasarnya, ini memberikan cara untuk menilai parameter seperti jumlah cluster dengan memberikan skor siluet. Skor ini adalah metrik yang mengukur seberapa dekat setiap titik dalam satu kluster dengan titik-titik di kluster tetangga.
Analisis skor siluet
Skor tersebut memiliki rentang [-1, 1]. Berikut adalah analisis skor ini -
Score of +1 - Skor mendekati +1 menunjukkan bahwa sampel berada jauh dari cluster tetangga.
Score of 0 - Skor 0 menunjukkan bahwa sampel berada pada atau sangat dekat dengan batas keputusan antara dua cluster yang bertetangga.
Score of -1 - Skor negatif menunjukkan bahwa sampel telah ditetapkan ke cluster yang salah.
Menghitung Skor Silhouette
Pada bagian ini, kita akan mempelajari cara menghitung skor siluet.
Skor siluet dapat dihitung dengan menggunakan rumus berikut -
$$ siluet skor = \ frac {\ kiri (pq \ kanan)} {maks \ kiri (p, q \ kanan)} $$
Di sini, adalah jarak rata-rata ke titik-titik di cluster terdekat yang titik datanya bukan bagiannya. Dan, adalah jarak intra-cluster rata-rata ke semua titik dalam clusternya sendiri.
Untuk menemukan jumlah cluster yang optimal, kita perlu menjalankan algoritma clustering lagi dengan mengimpor file metrics modul dari sklearnpaket. Dalam contoh berikut, kami akan menjalankan algoritme pengelompokan K-means untuk menemukan jumlah kluster yang optimal -
Impor paket yang diperlukan seperti yang ditunjukkan -
import matplotlib.pyplot as plt
import seaborn as sns; sns.set()
import numpy as np
from sklearn.cluster import KMeans
Dengan bantuan kode berikut, kami akan menghasilkan dataset dua dimensi, yang berisi empat blob, dengan menggunakan make_blob dari sklearn.dataset paket.
from sklearn.datasets.samples_generator import make_blobs
X, y_true = make_blobs(n_samples = 500, centers = 4, cluster_std = 0.40, random_state = 0)
Inisialisasi variabel seperti yang ditunjukkan -
scores = []
values = np.arange(2, 10)
Kita perlu mengulang model K-means melalui semua nilai dan juga perlu melatihnya dengan data masukan.
for num_clusters in values:
kmeans = KMeans(init = 'k-means++', n_clusters = num_clusters, n_init = 10)
kmeans.fit(X)
Sekarang, perkirakan skor siluet untuk model pengelompokan saat ini menggunakan metrik jarak Euclidean -
score = metrics.silhouette_score(X, kmeans.labels_,
metric = 'euclidean', sample_size = len(X))
Baris kode berikut akan membantu dalam menampilkan jumlah cluster serta skor Silhouette.
print("\nNumber of clusters =", num_clusters)
print("Silhouette score =", score)
scores.append(score)
Anda akan menerima output berikut -
Number of clusters = 9
Silhouette score = 0.340391138371
num_clusters = np.argmax(scores) + values[0]
print('\nOptimal number of clusters =', num_clusters)
Sekarang, keluaran untuk jumlah cluster yang optimal adalah sebagai berikut -
Optimal number of clusters = 2
Menemukan Tetangga Terdekat
Jika kita ingin membangun sistem rekomendasi seperti sistem rekomendasi film maka kita perlu memahami konsep menemukan tetangga terdekat. Pasalnya, sistem recommender menggunakan konsep tetangga terdekat.
Itu concept of finding nearest neighborsdapat didefinisikan sebagai proses menemukan titik terdekat ke titik masukan dari kumpulan data yang diberikan. Kegunaan utama dari algoritma KNN) K-nearest neighbours ini adalah untuk membangun sistem klasifikasi yang mengklasifikasikan suatu titik data pada kedekatan titik data masukan ke berbagai kelas.
Kode Python yang diberikan di bawah ini membantu menemukan K-terdekat tetangga dari kumpulan data tertentu -
Impor paket yang diperlukan seperti yang ditunjukkan di bawah ini. Di sini, kami menggunakanNearestNeighbors modul dari sklearn paket
import numpy as np
import matplotlib.pyplot as plt
from sklearn.neighbors import NearestNeighbors
Sekarang mari kita tentukan input data -
A = np.array([[3.1, 2.3], [2.3, 4.2], [3.9, 3.5], [3.7, 6.4], [4.8, 1.9],
[8.3, 3.1], [5.2, 7.5], [4.8, 4.7], [3.5, 5.1], [4.4, 2.9],])
Sekarang, kita perlu mendefinisikan tetangga terdekat -
k = 3
Kami juga perlu memberikan data uji dari mana tetangga terdekat dapat ditemukan -
test_data = [3.3, 2.9]
Kode berikut dapat memvisualisasikan dan memplot data input yang ditentukan oleh kami -
plt.figure()
plt.title('Input data')
plt.scatter(A[:,0], A[:,1], marker = 'o', s = 100, color = 'black')
Sekarang, kita perlu membangun K Tetangga Terdekat. Objeknya juga perlu dilatih
knn_model = NearestNeighbors(n_neighbors = k, algorithm = 'auto').fit(X)
distances, indices = knn_model.kneighbors([test_data])
Sekarang, kita dapat mencetak K tetangga terdekat sebagai berikut
print("\nK Nearest Neighbors:")
for rank, index in enumerate(indices[0][:k], start = 1):
print(str(rank) + " is", A[index])
Kita dapat memvisualisasikan tetangga terdekat bersama dengan titik data pengujian
plt.figure()
plt.title('Nearest neighbors')
plt.scatter(A[:, 0], X[:, 1], marker = 'o', s = 100, color = 'k')
plt.scatter(A[indices][0][:][:, 0], A[indices][0][:][:, 1],
marker = 'o', s = 250, color = 'k', facecolors = 'none')
plt.scatter(test_data[0], test_data[1],
marker = 'x', s = 100, color = 'k')
plt.show()
Keluaran
K Nearest Neighbors
1 is [ 3.1 2.3]
2 is [ 3.9 3.5]
3 is [ 4.4 2.9]
Klasifikasi K-Tetangga Terdekat
Pengklasifikasi K-Nearest Neighbours (KNN) adalah model klasifikasi yang menggunakan algoritma tetangga terdekat untuk mengklasifikasikan titik data tertentu. Kami telah mengimplementasikan algoritma KNN di bagian terakhir, sekarang kami akan membangun pengklasifikasi KNN menggunakan algoritma itu.
Konsep Pengklasifikasi KNN
Konsep dasar klasifikasi K-terdekat tetangga adalah untuk menemukan nomor yang telah ditetapkan, yaitu, 'k' - sampel pelatihan yang terdekat dengan jarak sampel baru, yang harus diklasifikasikan. Sampel baru akan mendapatkan labelnya dari tetangga itu sendiri. Pengklasifikasi KNN memiliki pengguna tetap yang ditentukan konstan untuk jumlah tetangga yang harus ditentukan. Untuk jarak, jarak Euclide standar adalah pilihan paling umum. Pengklasifikasi KNN bekerja secara langsung pada sampel yang dipelajari daripada membuat aturan untuk pembelajaran. Algoritme KNN adalah salah satu yang paling sederhana dari semua algoritme pembelajaran mesin. Ini telah cukup berhasil dalam sejumlah besar masalah klasifikasi dan regresi, misalnya, pengenalan karakter atau analisis gambar.
Example
Kami sedang membangun pengklasifikasi KNN untuk mengenali digit. Untuk ini, kami akan menggunakan dataset MNIST. Kami akan menulis kode ini di Notebook Jupyter.
Impor paket yang diperlukan seperti yang ditunjukkan di bawah ini.
Di sini kami menggunakan KNeighborsClassifier modul dari sklearn.neighbors paket -
from sklearn.datasets import *
import pandas as pd
%matplotlib inline
from sklearn.neighbors import KNeighborsClassifier
import matplotlib.pyplot as plt
import numpy as np
Kode berikut akan menampilkan gambar digit untuk memverifikasi gambar apa yang harus kita uji -
def Image_display(i):
plt.imshow(digit['images'][i],cmap = 'Greys_r')
plt.show()
Sekarang, kita perlu memuat dataset MNIST. Sebenarnya ada total 1797 gambar tetapi kami menggunakan 1600 gambar pertama sebagai sampel pelatihan dan 197 sisanya akan disimpan untuk tujuan pengujian.
digit = load_digits()
digit_d = pd.DataFrame(digit['data'][0:1600])
Sekarang, saat menampilkan gambar kita dapat melihat outputnya sebagai berikut -
Image_display(0)
Image_display (0)
Gambar 0 ditampilkan sebagai berikut -
Image_display (9)
Gambar 9 ditampilkan sebagai berikut -
digit.keys ()
Sekarang, kita perlu membuat kumpulan data pelatihan dan pengujian dan menyediakan kumpulan data pengujian ke pengklasifikasi KNN.
train_x = digit['data'][:1600]
train_y = digit['target'][:1600]
KNN = KNeighborsClassifier(20)
KNN.fit(train_x,train_y)
Output berikut akan membuat konstruktor pengklasifikasi tetangga terdekat K -
KNeighborsClassifier(algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
metric_params = None, n_jobs = 1, n_neighbors = 20, p = 2,
weights = 'uniform')
Kita perlu membuat sampel pengujian dengan memberikan nomor arbitrer yang lebih besar dari 1600, yang merupakan sampel pelatihan.
test = np.array(digit['data'][1725])
test1 = test.reshape(1,-1)
Image_display(1725)
Image_display (6)
Gambar 6 ditampilkan sebagai berikut -
Sekarang kami akan memprediksi data pengujian sebagai berikut -
KNN.predict(test1)
Kode di atas akan menghasilkan output berikut -
array([6])
Sekarang, pertimbangkan yang berikut -
digit['target_names']
Kode di atas akan menghasilkan output berikut -
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])