DBSCAN dengan Scikit-Learn dengan Python

Pengantar

Anda bekerja di perusahaan konsultan sebagai ilmuwan data. Proyek yang saat ini Anda tugaskan memiliki data dari siswa yang baru saja menyelesaikan kursus tentang keuangan. Perusahaan keuangan yang menyelenggarakan kursus ingin memahami apakah ada faktor umum yang memengaruhi siswa untuk membeli kursus yang sama atau membeli kursus yang berbeda. Dengan memahami faktor-faktor tersebut, perusahaan dapat membuat profil siswa, mengklasifikasikan setiap siswa berdasarkan profil, dan merekomendasikan daftar mata kuliah.

Saat memeriksa data dari kelompok siswa yang berbeda, Anda menemukan tiga disposisi poin, seperti pada 1, 2, dan 3 di bawah ini:

Perhatikan bahwa di plot 1, ada titik ungu yang diatur dalam setengah lingkaran, dengan massa titik merah muda di dalam lingkaran itu, sedikit konsentrasi titik oranye di luar setengah lingkaran itu, dan lima titik abu-abu yang jauh dari yang lainnya.

Di petak 2, ada massa bulat titik ungu, titik jingga lainnya, dan juga empat titik abu-abu yang jauh dari yang lain.

Dan di plot 3, kita bisa melihat empat titik konsentrasi, ungu, biru, oranye, merah muda, dan tiga titik abu-abu yang lebih jauh.

Sekarang, jika Anda memilih model yang dapat memahami data siswa baru dan menentukan kelompok serupa, apakah ada algoritma pengelompokan yang dapat memberikan hasil yang menarik untuk jenis data tersebut?

Saat mendeskripsikan plot, kami menyebutkan istilah seperti massa poin dan konsentrasi poin, menunjukkan bahwa ada area di semua grafik dengan kepadatan lebih besar. Kami juga merujuk bundar dan berbentuk setengah lingkaran bentuk, yang sulit diidentifikasi dengan menggambar garis lurus atau hanya dengan mengamati titik-titik terdekat. Selain itu, ada beberapa titik jauh yang kemungkinan menyimpang dari distribusi data utama, menimbulkan lebih banyak tantangan atau kebisingan dalam menentukan kelompok.

Algoritme berbasis kepadatan yang dapat menyaring kebisingan, seperti DBSCAN (Dentitas-Based Ssabar Ckilau Aaplikasi dengan Noise), adalah pilihan yang kuat untuk situasi dengan area yang lebih padat, bentuk bulat, dan kebisingan.

Tentang DBSCAN

DBSCAN adalah salah satu algoritma yang paling banyak dikutip dalam penelitian, publikasi pertamanya muncul pada tahun 1996, ini adalah kertas DBSCAN asli. Dalam makalah tersebut, para peneliti mendemonstrasikan bagaimana algoritma dapat mengidentifikasi cluster spasial non-linear dan menangani data dengan dimensi yang lebih tinggi secara efisien.

Ide utama di balik DBSCAN adalah bahwa ada jumlah titik minimum yang akan berada dalam jarak tertentu atau radius dari titik klaster paling "sentral", disebut titik inti. Titik-titik dalam radius itu adalah titik-titik ketetanggaan, dan titik-titik di tepi ketetanggaan itu adalah titik perbatasan or titik batas. Jari-jari atau jarak lingkungan disebut lingkungan epsilon, ε-lingkungan atau hanya ε (simbol untuk huruf Yunani epsilon).

Selain itu, ketika ada titik yang bukan titik inti atau titik perbatasan karena melebihi radius untuk menjadi bagian dari cluster yang ditentukan dan juga tidak memiliki jumlah titik minimum untuk menjadi titik inti, titik tersebut dianggap titik kebisingan.

Ini berarti kita memiliki tiga jenis poin, yaitu, inti, batas dan kebisingan. Selain itu, penting untuk dicatat bahwa gagasan utama pada dasarnya didasarkan pada radius atau jarak, yang membuat DBSCAN – seperti kebanyakan model pengelompokan – bergantung pada metrik jarak tersebut. Metrik ini bisa Euclidean, Manhattan, Mahalanobis, dan banyak lagi. Oleh karena itu, sangat penting untuk memilih metrik jarak yang tepat yang mempertimbangkan konteks data. Misalnya, jika Anda menggunakan data jarak mengemudi dari GPS, mungkin menarik untuk menggunakan metrik yang mempertimbangkan tata letak jalan, seperti jarak Manhattan.

Untuk menemukan titik inti, DBSCAN pertama-tama akan memilih sebuah titik secara acak, memetakan semua titik di dalam ε-neighborhood-nya, dan membandingkan jumlah tetangga dari titik yang dipilih dengan jumlah titik minimum. Jika titik yang dipilih memiliki jumlah yang sama atau lebih banyak tetangga dari jumlah minimum titik, itu akan ditandai sebagai titik inti. Titik inti ini dan titik lingkungannya akan menjadi klaster pertama.

Algoritme kemudian akan memeriksa setiap titik dari klaster pertama dan melihat apakah ia memiliki jumlah titik tetangga yang sama atau lebih banyak dari jumlah minimum titik dalam ε. Jika ya, titik tetangga tersebut juga akan ditambahkan ke cluster pertama. Proses ini akan berlanjut hingga titik-titik dari klaster pertama memiliki tetangga yang lebih sedikit daripada jumlah minimum titik dalam ε. Saat itu terjadi, algoritme berhenti menambahkan titik ke klaster tersebut, mengidentifikasi titik inti lain di luar klaster tersebut, dan membuat klaster baru untuk titik inti baru tersebut.

DBSCAN kemudian akan mengulang proses cluster pertama untuk menemukan semua titik yang terhubung ke titik inti baru dari cluster kedua hingga tidak ada lagi titik yang akan ditambahkan ke cluster tersebut. Ini kemudian akan menemukan titik inti lain dan membuat cluster ketiga, atau akan beralih melalui semua titik yang belum pernah dilihat sebelumnya. Jika titik-titik ini berada pada jarak ε dari sebuah cluster, mereka ditambahkan ke cluster tersebut, menjadi titik perbatasan. Jika tidak, mereka dianggap sebagai titik kebisingan.

Sangat menarik untuk mengetahui bagaimana algoritma DBSCAN bekerja, meskipun, untungnya, tidak perlu mengkodekan algoritma, setelah pustaka Scikit-Learn Python sudah memiliki implementasi.

Mari kita lihat cara kerjanya dalam praktik!

Mengimpor Data untuk Pengelompokan

Untuk melihat bagaimana DBSCAN bekerja dalam praktiknya, kami akan mengubah proyek sedikit dan menggunakan kumpulan data pelanggan kecil yang memiliki genre, usia, pendapatan tahunan, dan skor pengeluaran 200 pelanggan.

Skor pengeluaran berkisar dari 0 hingga 100 dan mewakili seberapa sering seseorang menghabiskan uang di mal dalam skala dari 1 hingga 100. Dengan kata lain, jika pelanggan memiliki skor 0, mereka tidak pernah membelanjakan uang, dan jika skornya adalah 100, mereka adalah pembelanja tertinggi.

Setelah mengunduh kumpulan data, Anda akan melihat bahwa itu adalah file CSV (comma-separated values) bernama belanja-data.csv, kami akan memuatnya ke dalam DataFrame menggunakan Pandas dan menyimpannya ke dalam customer_data variabel:

import pandas as pd path_to_file = '../../datasets/dbscan/dbscan-with-python-and-scikit-learn-shopping-data.csv'
customer_data = pd.read_csv(path_to_file)

Untuk melihat lima baris pertama dari data kami, Anda dapat mengeksekusi customer_data.head():

Ini menghasilkan:

 CustomerID Genre Age Annual Income (k$) Spending Score (1-100)
0 1 Male 19 15 39
1 2 Male 21 15 81
2 3 Female 20 16 6
3 4 Female 23 16 77
4 5 Female 31 17 40

Dengan memeriksa data, kita dapat melihat nomor ID pelanggan, genre, usia, pendapatan dalam k$, dan skor pengeluaran. Perlu diingat bahwa beberapa atau semua variabel ini akan digunakan dalam model. Misalnya, jika kita akan menggunakan Age dan Spending Score (1-100) sebagai variabel untuk DBSCAN, yang menggunakan metrik jarak, penting untuk membawanya ke skala umum untuk menghindari distorsi sejak Age diukur dalam tahun dan Spending Score (1-100) memiliki rentang terbatas dari 0 hingga 100. Artinya, kami akan melakukan semacam penskalaan data.

Kita juga dapat memeriksa apakah data memerlukan preprocessing selain penskalaan dengan melihat apakah tipe data konsisten dan memverifikasi apakah ada nilai yang hilang yang perlu ditangani dengan mengeksekusi Panda's info() Metode:

customer_data.info()

Ini menampilkan:

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 200 entries, 0 to 199
Data columns (total 5 columns): # Column Non-Null Count Dtype --- ------ -------------- ----- 0 CustomerID 200 non-null int64 1 Genre 200 non-null object 2 Age 200 non-null int64 3 Annual Income (k$) 200 non-null int64 4 Spending Score (1-100) 200 non-null int64 dtypes: int64(4), object(1)
memory usage: 7.9+ KB

Kita dapat mengamati bahwa tidak ada nilai yang hilang karena terdapat 200 entri non-null untuk setiap fitur pelanggan. Kita juga dapat melihat bahwa hanya kolom genre yang memiliki konten teks, karena merupakan variabel kategori, yang ditampilkan sebagai object, dan semua fitur lainnya adalah numerik, dari jenisnya int64. Jadi, dalam hal konsistensi tipe data dan tidak adanya nilai nol, data kami siap untuk analisis lebih lanjut.

Kami dapat melanjutkan untuk memvisualisasikan data dan menentukan fitur mana yang menarik untuk digunakan di DBSCAN. Setelah memilih fitur tersebut, kita dapat menskalakannya.

Kumpulan data pelanggan ini sama dengan yang digunakan dalam panduan definitif kami untuk pengelompokan hierarkis. Untuk mempelajari lebih lanjut tentang data ini, cara menjelajahinya, dan tentang metrik jarak, Anda dapat melihatnya Panduan Definitif untuk Pengelompokan Hirarki dengan Python dan Scikit-Learn!

Memvisualisasikan Data

Dengan menggunakan Seaborn's pairplot(), kita dapat memplot grafik pencar untuk setiap kombinasi fitur. Sejak CustomerID hanyalah identifikasi dan bukan fitur, kami akan menghapusnya bersama drop() sebelum memplot:

import seaborn as sns customer_data = customer_data.drop('CustomerID', axis=1) sns.pairplot(customer_data);

Output ini:

Ketika melihat kombinasi fitur yang dihasilkan oleh pairplot, grafik dari Annual Income (k$) dengan Spending Score (1-100) tampaknya menampilkan sekitar 5 kelompok poin. Ini tampaknya merupakan kombinasi fitur yang paling menjanjikan. Kami dapat membuat daftar dengan nama mereka, memilihnya dari customer_data DataFrame, dan simpan pilihan di customer_data variabel lagi untuk digunakan dalam model masa depan kita.

selected_cols = ['Annual Income (k$)', 'Spending Score (1-100)']
customer_data = customer_data[selected_cols]

Setelah memilih kolom, kita dapat melakukan penskalaan yang dibahas di bagian sebelumnya. Untuk membawa fitur ke skala yang sama atau membakukan mereka, kita dapat mengimpor Scikit-Learn's StandardScaler, buat, paskan data kami untuk menghitung rata-rata dan simpangan bakunya, dan ubah data dengan mengurangkan rata-ratanya dan membaginya dengan simpangan baku. Hal ini dapat dilakukan dalam satu langkah dengan fit_transform() Metode:

from sklearn.preprocessing import StandardScaler ss = StandardScaler() scaled_data = ss.fit_transform(customer_data)

Variabel sekarang diskalakan, dan kita dapat memeriksanya hanya dengan mencetak konten dari scaled_data variabel. Atau, kami juga dapat menambahkannya ke yang baru scaled_customer_data DataFrame bersama dengan nama kolom dan gunakan head() metode lagi:

scaled_customer_data = pd.DataFrame(columns=selected_cols, data=scaled_data)
scaled_customer_data.head()

Output ini:

 Annual Income (k$) Spending Score (1-100)
0 -1.738999 -0.434801
1 -1.738999 1.195704
2 -1.700830 -1.715913
3 -1.700830 1.040418
4 -1.662660 -0.395980 

Data ini siap untuk pengelompokan! Saat memperkenalkan DBSCAN, kami menyebutkan jumlah minimum poin dan epsilon. Kedua nilai ini perlu dipilih sebelum membuat model. Mari kita lihat bagaimana hal itu dilakukan.

Memilih Min. Sampel dan Epsilon

Untuk memilih jumlah poin minimum untuk pengelompokan DBSCAN, ada aturan praktis yang menyatakan bahwa itu harus sama atau lebih tinggi dari jumlah dimensi dalam data ditambah satu, seperti pada:

$$
teks{min. poin} >= teks{dimensi data} + 1
$$

Dimensi adalah jumlah kolom dalam kerangka data, kami menggunakan 2 kolom, jadi min. poin harus 2+1, yaitu 3, atau lebih tinggi. Untuk contoh ini, mari kita gunakan 5 menit. poin.

$$
teks{5 (poin min.)} >= teks{2 (dimensi data)} + 1
$$

Sekarang, untuk memilih nilai ε ada metode dimana a Tetangga Terdekat Algoritma digunakan untuk menemukan jarak dari sejumlah titik terdekat yang telah ditentukan sebelumnya untuk setiap titik. Jumlah tetangga yang telah ditentukan ini adalah min. poin yang baru saja kita pilih minus 1. Jadi, dalam kasus kita, algoritme akan menemukan 5-1, atau 4 titik terdekat untuk setiap titik data kita. itu adalah k-tetangga dan kami k sama dengan 4.

$$
teks{k-tetangga} = teks{min. poin} – 1
$$

Setelah menemukan tetangga, kita akan mengurutkan jaraknya dari yang terbesar ke yang terkecil dan memplot jarak sumbu y dan titik-titik pada sumbu x. Melihat plot, kita akan menemukan di mana itu menyerupai bengkok siku dan titik sumbu y yang menggambarkan bahwa bengkok siku adalah nilai ε yang disarankan.

Untuk melakukan langkah-langkah ini, kita dapat mengimpor algoritme, menyesuaikannya dengan data, lalu mengekstrak jarak dan indeks setiap titik dengan kneighbors() Metode:

from sklearn.neighbors import NearestNeighbors
import numpy as np nn = NearestNeighbors(n_neighbors=4) nbrs = nn.fit(scaled_customer_data)
distances, indices = nbrs.kneighbors(scaled_customer_data)

Setelah menemukan jaraknya, kita dapat mengurutkannya dari yang terbesar hingga yang terkecil. Karena kolom pertama dari array distances adalah titik ke dirinya sendiri (artinya semua adalah 0), dan kolom kedua berisi jarak terkecil, diikuti oleh kolom ketiga yang memiliki jarak lebih besar dari yang kedua, dan seterusnya, kita hanya dapat memilih nilai kolom kedua dan menyimpannya di distances variabel:

distances = np.sort(distances, axis=0)
distances = distances[:,1] 

Sekarang setelah kita memiliki jarak terkecil yang diurutkan, kita dapat mengimpor matplotlib, plot jaraknya, dan gambar garis merah di tempat "tikungan siku" berada:

import matplotlib.pyplot as plt plt.figure(figsize=(6,3))
plt.plot(distances)
plt.axhline(y=0.24, color='r', linestyle='--', alpha=0.4) plt.title('Kneighbors distance graph')
plt.xlabel('Data points')
plt.ylabel('Epsilon value')
plt.show();

Ini adalah hasilnya:

Perhatikan bahwa saat menggambar garis, kita akan mengetahui nilai ε, dalam hal ini adalah 0.24.

Kami akhirnya memiliki poin minimum dan ε. Dengan kedua variabel tersebut, kita dapat membuat dan menjalankan model DBSCAN.

Membuat Model DBSCAN

Untuk membuat modelnya, kita dapat mengimpornya dari Scikit-Learn, membuatnya dengan ε yang sama dengan eps argumen, dan poin minimum yang merupakan mean_samples argumen. Kami kemudian dapat menyimpannya ke dalam variabel, sebut saja dbs dan paskan dengan data yang diskalakan:

from sklearn.cluster import DBSCAN dbs = DBSCAN(eps=0.24, min_samples=5)
dbs.fit(scaled_customer_data)

Begitu saja, model DBSCAN kami telah dibuat dan dilatih berdasarkan data! Untuk mengekstrak hasilnya, kita mengakses labels_ Properti. Kita juga bisa membuat yang baru labels kolom di scaled_customer_data bingkai data dan isi dengan label yang diprediksi:

labels = dbs.labels_ scaled_customer_data['labels'] = labels
scaled_customer_data.head()

Ini adalah hasil akhirnya:

 Annual Income (k$) Spending Score (1-100) labels
0 -1.738999 -0.434801 -1
1 -1.738999 1.195704 0
2 -1.700830 -1.715913 -1
3 -1.700830 1.040418 0
4 -1.662660 -0.395980 -1

Perhatikan bahwa kami memiliki label dengan -1 nilai; ini adalah titik kebisingan, yang bukan milik kluster mana pun. Untuk mengetahui berapa banyak noise point yang ditemukan algoritme, kita dapat menghitung berapa kali nilai -1 muncul di daftar label kita:

labels_list = list(scaled_customer_data['labels'])
n_noise = labels_list.count(-1)
print("Number of noise points:", n_noise)

Output ini:

Number of noise points: 62

Kami sudah tahu bahwa 62 poin dari data asli kami dari 200 poin dianggap sebagai noise. Ini banyak kebisingan, yang menunjukkan bahwa mungkin pengelompokan DBSCAN tidak mempertimbangkan banyak poin sebagai bagian dari sebuah cluster. Kami akan segera memahami apa yang terjadi, saat kami memplot datanya.

Awalnya, ketika kami mengamati data, tampaknya ada 5 cluster poin. Untuk mengetahui berapa banyak cluster DBSCAN yang terbentuk, kita dapat menghitung jumlah label yang bukan -1. Ada banyak cara untuk menulis kode tersebut; di sini, kami telah menulis perulangan for, yang juga akan berfungsi untuk data di mana DBSCAN telah menemukan banyak kluster:

total_labels = np.unique(labels) n_labels = 0
for n in total_labels: if n != -1: n_labels += 1
print("Number of clusters:", n_labels)

Output ini:

Number of clusters: 6

Kita dapat melihat bahwa algoritme memprediksi data memiliki 6 cluster, dengan banyak titik noise. Mari kita bayangkan dengan memplotnya dengan seaborn's scatterplot:

sns.scatterplot(data=scaled_customer_data, x='Annual Income (k$)', y='Spending Score (1-100)', hue='labels', palette='muted').set_title('DBSCAN found clusters');

Ini menghasilkan:

Melihat plotnya, kita dapat melihat bahwa DBSCAN telah menangkap titik-titik yang terhubung lebih padat, dan titik-titik yang dapat dianggap sebagai bagian dari cluster yang sama adalah noise atau dianggap membentuk cluster lain yang lebih kecil.

Jika kita menyorot klaster, perhatikan bagaimana DBSCAN mendapatkan klaster 1 sepenuhnya, yang merupakan klaster dengan ruang antar titik yang lebih sedikit. Kemudian ia mendapatkan bagian dari cluster 0 dan 3 di mana titik-titiknya berdekatan, dengan mempertimbangkan titik-titik yang lebih berjarak sebagai noise. Itu juga menganggap titik di bagian kiri bawah sebagai noise dan membagi titik di kanan bawah menjadi 3 kelompok, sekali lagi menangkap kelompok 4, 2, dan 5 di mana titik-titik tersebut lebih dekat satu sama lain.

Kita dapat mulai sampai pada kesimpulan bahwa DBSCAN sangat bagus untuk menangkap area padat cluster tetapi tidak begitu banyak untuk mengidentifikasi skema data yang lebih besar, delimitasi 5 cluster. Akan menarik untuk menguji lebih banyak algoritme pengelompokan dengan data kami. Mari kita lihat apakah metrik akan menguatkan hipotesis ini.

Mengevaluasi Algoritma

Untuk mengevaluasi DBSCAN kita akan menggunakan skor siluet yang akan mempertimbangkan jarak antar titik dalam cluster yang sama dan jarak antar cluster.

Pertama, kita bisa mengimpor silhouette_score dari Scikit-Learn, lalu berikan kolom dan label kami:

from sklearn.metrics import silhouette_score s_score = silhouette_score(scaled_customer_data, labels)
print(f"Silhouette coefficient: {s_score:.3f}")

Output ini:

Silhouette coefficient: 0.506

Menurut skor ini, tampaknya DBSCAN dapat menangkap sekitar 50% data.

Kesimpulan

Keuntungan dan Kerugian DBSCAN

DBSCAN adalah algoritma atau model pengelompokan yang sangat unik.

Jika kita lihat kelebihannya, sangat bagus dalam mengambil area padat di data dan titik yang jauh dari yang lain. Artinya, data tidak harus memiliki bentuk tertentu dan dapat dikelilingi oleh titik-titik lain, asalkan juga terhubung dengan rapat.

Ini mengharuskan kita untuk menentukan titik minimum dan ε, tetapi tidak perlu menentukan jumlah cluster terlebih dahulu, seperti di K-Means, misalnya. Itu juga dapat digunakan dengan database yang sangat besar karena dirancang untuk data dimensi tinggi.

Mengenai kerugiannya, kami telah melihat bahwa ia tidak dapat menangkap kepadatan yang berbeda dalam cluster yang sama, sehingga mengalami kesulitan dengan perbedaan kepadatan yang besar. Itu juga tergantung pada metrik jarak dan penskalaan poin. Ini berarti bahwa jika data tidak dipahami dengan baik, dengan perbedaan skala dan dengan metrik jarak yang tidak masuk akal, mungkin akan gagal untuk memahaminya.

Ekstensi DBSCAN

Ada algoritma lain, seperti DBSCAN hierarkis (HDBSCAN) dan Titik pemesanan untuk mengidentifikasi struktur pengelompokan (OPTIK), yang dianggap sebagai ekstensi dari DBSCAN.

HDBSCAN dan OPTICS biasanya dapat bekerja lebih baik ketika ada cluster dengan kepadatan yang bervariasi dalam data dan juga kurang sensitif terhadap pilihan atau min awal. poin dan parameter ε.

• Konten Bertenaga SEO & Distribusi PR. Dapatkan Amplifikasi Hari Ini.
• Platoblockchain. Intelijen Metaverse Web3. Pengetahuan Diperkuat. Akses Di Sini.
• Sumber: https://stackabuse.com/dbscan-with-scikit-learn-in-python/