Pendahuluan
Okay-Nearest Neighbors (KNN) merupakan algoritma supervised studying yang digunakan untuk klasifikasi dan regresi dalam knowledge. Dalam konteks klasifikasi, KNN bekerja dengan mengidentifikasi kategori mayoritas dari tetangga terdekat suatu objek berdasarkan sejumlah tetangga (disebut Okay) yang dipilih sebelumnya.
Langkah-Langkah dalam Algoritma KNN
- Pilih Parameter Okay:
Pilih jumlah tetangga terdekat (Okay). Ini adalah jumlah titik knowledge tetangga yang akan dipertimbangkan oleh algoritma untuk membuat keputusan. - Hitung Jarak:
Hitung jarak antara titik knowledge baru dengan semua titik knowledge dalam dataset pelatihan. Beberapa metrik jarak yang umum digunakan termasuk:
– Jarak Euclidean: d(x,y) = √Σ(xi – yi)²
– Jarak Manhattan: d(x,y) = Σ|xi – yi|
– Jarak Minkowski: Sebuah generalisasi dari jarak Euclidean dan Manhattan - Identifikasi Okay Tetangga Terdekat:
Pilih Okay titik knowledge dari dataset pelatihan yang memiliki jarak terdekat dengan titik knowledge baru. - Klasifikasi:
-Hitung frekuensi dari kelas-kelas Okay tetangga terdekat.
– Tetapkan titik knowledge baru ke kelas yang paling umum (mayoritas) di antara Okay tetangga terdekat.
Contoh Penerapan KNN dalam Mengidentifikasi Jenis Kurma
Dataset
Knowledge yang digunakan pada penerapan algoritma KNN kali ini berasal dari UC Irvine Machine Studying Repository
Dataset ini mencakup dua jenis kurma, Ajwa dan Medjool. Dalam dataset ini terdapat berbagai fitur seperti panjang buah, diameter buah, berat buah, panjang biji, kalori, dan warna yang berguna untuk membedakan antara kedua jenis kurma tersebut.
Selanjutnya, knowledge tersebut akan diklasifikasikan menggunakan metode KNN dengan Python.
Exploration Knowledge Evaluation
Knowledge akan dieksplorasi dan dianalisis untuk menentukan langkah selanjutnya.
# Import Bundle yang diperlukan
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
# Menampilkan 5 knowledge pertama
knowledge = pd.read_csv("AjwaOrMejdool.csv")
knowledge.head()
#Mengubah nama dari setiap fitur agar mudah dikenali
knowledge = knowledge.rename(
columns={'DateLength_cm': 'panjang_buah',
'DateDiameter_cm' : 'diameter_buah',
'DateWeight_g' : 'berat_buah',
'PitLength_cm' : 'panjang_biji',
'Calories_Kcal' : 'kalori',
'Coloration' : 'warna',
'Class' : 'jenis'}
)# Membuat file csv baru dengan nama fitur yang telah dirubah
knowledge.to_csv('dataKurma_indo.csv')
# Menampilkan 5 knowledge pertama yang sudah diubah
knowledge = pd.read_csv("dataKurma_indo.csv", index_col=0)
knowledge.head()
# Menampilkan informasi knowledge
knowledge.information()
# Menampilkan deskripsi knowledge
knowledge.describe()
# Mengecek knowledge yang hilang
print(knowledge.isnull().sum())
#Visualisasi jumlah knowledge goal dengan barplot menggunakan matplotlib
plt.determine(figsize=(4, 3))
sns.countplot(x='jenis', knowledge=knowledge)
plt.xlabel('Jenis Kurma')
plt.ylabel('Jumlah Knowledge')
plt.title('Banyaknya knowledge')
plt.present()
Knowledge Preprocessing
Setelah melakukan eksplorasi dan analisis knowledge, langkah selanjutnya adalah melakukan pemrosesan knowledge untuk mendapatkan knowledge yang sesuai dengan kebutuhan perancangan mannequin.
# Mapping goal variables
target_jenis = {'Ajwa': 0, 'Medjool': 1}
target_warna = {'Black': 0, 'Brown': 1}# Mengubah goal menjadi bentuk numerik 0 dan 1
knowledge['jenis'] = knowledge['jenis'].map(target_jenis)
knowledge['warna'] = knowledge['warna'].map(target_warna)
# Sampling knowledge (untuk merandom knowledge)
knowledge = knowledge.pattern(20).reset_index(drop=True)
# Visualisasi Field Plots menggunakan matplotlib untuk melihat outliers
fig, axs = plt.subplots(7, 1, dpi=95, figsize=(7, 17))
i = 0
for col in knowledge.columns:
axs[i].boxplot(knowledge[col], vert=False)
axs[i].set_ylabel(col)
i += 1
plt.present()
# Terlihat bahwa fitur diameter memiliki outliers# Dedeteksi outliers
Q1 = knowledge['diameter_buah'].quantile(0.25)
Q3 = knowledge['diameter_buah'].quantile(0.75)
IQR = Q3 - Q1
Batas_Bawah = Q1 - 1.5 * IQR
Batas_Atas = Q3 + 1.5 * IQR
print("Batas Bawah untuk outlier: ", Batas_Bawah)
print("Batas Atas untuk outlier: ", Batas_Atas)
# Melihat knowledge mana yang terdeteksi sebagai outliers
knowledge['outlier'] = (knowledge['diameter_buah'] < Batas_Bawah) | (knowledge['diameter_buah'] > Batas_Atas)
knowledge
# Menghapus knowledge yang terdeteksi seagai outliers
dataBersih = knowledge[~data['outlier']]
# Membuat plot fitur diameter untuk mengecek apakah outliers sudah berhasil dihapus
plt.determine(figsize=(8, 4))
sns.boxplot(x=dataBersih['diameter_buah'])
plt.xlabel('Diameter Buah')
plt.present()
# Visualisasi korelasi
data3 = dataBersih.drop(['jenis', 'outlier'], axis=1)
sns.heatmap(data3.corr(), annot=True)
plt.present()
# Memisahkan knowledge untuk dilakukan normalisasi
dataNumerik = dataBersih.drop(['jenis', 'outlier'], axis=1)
data_target = dataBersih['jenis']# Normalisasi knowledge
normalisasi = (dataNumerik - dataNumerik.min()) / (dataNumerik.max() - dataNumerik.min())
normalisasi.describe()
# Melihat 5 knowledge pertama yang sudah dinormalisasi
normalized_data = pd.concat([normalisasi, data_target], axis=1)
normalized_data.head()
Knowledge Splitting
Di sini, dataset dibagi dengan perbandingan 7:3, di mana 70% digunakan untuk coaching dan 30% untuk testing.
# Fungsi untuk membagi knowledge menjadi knowledge latih dan knowledge uji
def train_test_split(X, y, test_size=0.3):
split_index = int(len(X) * (1 - test_size))
X_train, X_test = X.iloc[:split_index], X.iloc[split_index:]
y_train, y_test = y.iloc[:split_index], y.iloc[split_index:]
return X_train, X_test, y_train, y_test
X = normalized_data.drop('jenis', axis=1)
y = normalized_data['jenis']
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)
Experiment Settings
Parameter Setting pada KNNokay (Jumlah Tetangga Terdekat):
– Parameter ini menentukan berapa banyak tetangga terdekat yang digunakan untuk menentukan kelas.
– Pemilihan nilai ‘okay’ biasanya berdasarkan eksperimen.Metric (Metode Pengukuran Jarak): Euclidean Distance
# Definisi fungsi jarak dan prediksi
def euclidean(a, b):
return np.sqrt(np.sum((a - b) ** 2))
# Untuk memprediksi goal
def predict(x, okay, data1, data2):
jarak = []
for _, row in data1.iterrows():
jarak.append(euclidean(x, row))dataNew = data1.copy()
dataNew['jarak'] = jarak
dataNew['jenis'] = data2
dataNew = dataNew.sort_values(by='jarak').reset_index(drop=True)
y_pred = dataNew.iloc[:k].jenis.mode()
return y_pred[0]
# Untuk melihat akurasi
def accuracy(y_pred, y_true):
n = len(y_pred)
benar = sum(y_pred[i] == y_true[i] for i in vary(n))
return (benar / n) * 100
Mannequin Coaching
Akan dilakukan prediksi pada knowledge uji untuk mendapatkan akurasi dari beberapa okay (Jumlah Tetangga Terdekat)
# Coaching dan evaluasi mannequin
for okay in [1, 3, 5, 7, 9, 11]:
# Prediksi pada knowledge uji
preds_test = [predict(X_test.iloc[i], okay, X_train, y_train) for i in vary(len(X_test))]
acc_test = accuracy(preds_test, checklist(y_test))print(f"Dengan okay = {okay}, akurasi pada knowledge uji adalah {acc_test:.2f}")
Mannequin Testing and Analysis
Akan dilakukan pengujian dengan enter dari consumer
# Fungsi untuk menerima enter dari pengguna dan melakukan prediksi
def predict_kurma():
features_data = dataBersih.drop(['warna', 'jenis', 'outlier'], axis=1)
target_data = dataBersih['jenis']panjangBuah = float(enter("Masukkan panjang buah (cm): "))
diameter = float(enter("Masukkan diameter (cm): "))
berat = float(enter("Masukkan berat buah (g): "))
panjangBiji = float(enter("Masukkan panjang biji (cm): "))
kalori = float(enter("Masukkan kalori buah (KKal): "))
input_data = np.array([panjangBuah, diameter, berat, panjangBiji, kalori])
normalisasi_input = (input_data - features_data.min()) / (features_data.max() - features_data.min())
okay = int(enter("Masukkan nilai okay: "))
prediction = predict(normalisasi_input, okay, features_data, target_data)
jenis_mapping = {0: 'Ajwa', 1: 'Medjool'}
print(f'Jenis kurma yang diprediksi: {jenis_mapping[prediction]}')
# Memanggil fungsi prediksi
predict_kurma()
Present the Efficiency
Melihat performa dari akurasi dengan okay (Jumlah Tetangga Terdekat) yang berbeda
train_accuracies = []
test_accuracies = []k_values = [1, 3, 5, 7, 9, 11, 13, 15]
outcomes = []
for okay in k_values:
# Practice accuracy
train_preds = [predict(X_train.iloc[i], okay, X_train, y_train) for i in vary(len(X_train))]
train_acc_k = accuracy(train_preds, checklist(y_train))
# Take a look at accuracy
test_preds = [predict(X_test.iloc[i], okay, X_train, y_train) for i in vary(len(X_test))]
test_acc_k = accuracy(test_preds, checklist(y_test))
train_accuracies.append(train_acc_k)
test_accuracies.append(test_acc_k)
outcomes.append([k, train_acc_k, test_acc_k])
results_df = pd.DataFrame(outcomes, columns=['k', 'Mean Train Accuracy', 'Mean Test Accuracy'])
print(results_df)
# Plotting the accuracies
plt.determine(figsize=(8, 4))
plt.plot(k_values, train_accuracies, label='Practice Accuracy', marker='o')
plt.plot(k_values, test_accuracies, label='Take a look at Accuracy', marker='o')
plt.xlabel('okay')
plt.ylabel('Accuracy')
plt.title('KNN Practice and Take a look at Accuracies for Totally different okay Values')
plt.legend()
plt.grid(True)
plt.present()
# Plot outcomes
class_ajwa_train = X_train[y_train == 0]
class_medjool_train = X_train[y_train == 1]class_ajwa_test = X_test[y_test == 0]
class_medjool_test = X_test[y_test == 1]
plt.determine(figsize=(10, 6))
plt.scatter(class_ajwa_train.iloc[:, 0], class_ajwa_train.iloc[:, 1], coloration='blue', label='Ajwa (Practice)')
plt.scatter(class_medjool_train.iloc[:, 0], class_medjool_train.iloc[:, 1], coloration='inexperienced', label='Medjool (Practice)')
plt.scatter(class_ajwa_test.iloc[:, 0], class_ajwa_test.iloc[:, 1], coloration='blue', edgecolor='black', label='Ajwa (Take a look at)', marker='s', s=100)
plt.scatter(class_medjool_test.iloc[:, 0], class_medjool_test.iloc[:, 1], coloration='inexperienced', edgecolor='black', label='Medjool (Take a look at)', marker='s', s=100)
plt.scatter(X_test.iloc[:, 0], X_test.iloc[:, 1], facecolors='none', edgecolors='r', marker='o', s=200, label='Predictions')
plt.xlabel('Characteristic 1')
plt.ylabel('Characteristic 2')
plt.legend()
plt.title('KNN Classification Visualization')
plt.grid(True)
plt.present()
Hasil dan Analisis
- Nilai okay yang Optimum: Berdasarkan grafik, nilai okay yang optimum berada pada kisaran okay = 3 hingga okay = 7, dimana akurasi pengujian masih tinggi dan stabil. Akurasi pengujian mulai turun tajam setelah okay = 7.
- Overfitting: Pada nilai okay = 1, mannequin menunjukkan akurasi pelatihan yang sangat tinggi (100%) dan akurasi pengujian juga sangat tinggi (100%). Namun, pada umumnya okay yang terlalu kecil seperti okay = 1 cenderung menunjukkan tanda-tanda overfitting karena mannequin terlalu kompleks dan sangat sensitif terhadap knowledge pelatihan.
- Underfitting: Pada nilai okay yang lebih besar (okay > 7), baik akurasi pelatihan maupun pengujian menurun tajam. Misalnya, untuk okay = 9 dan seterusnya (okay = 11, 13, 15), akurasi pengujian mendekati 0%, menunjukkan bahwa mannequin menjadi terlalu sederhana dan tidak dapat menangkap pola dalam knowledge, yaitu underfitting yang sangat parah.
Kesimpulan
- Disarankan memilih nilai okay di sekitar 3 hingga 7 untuk mannequin KNN ini untuk menjaga akurasi pengujian tetap tinggi.
- Hindari nilai okay yang lebih besar dari 7 karena akan menyebabkan underfitting yang signifikan.
- Evaluasi lebih lanjut dengan menggunakan lebih banyak knowledge, karena knowledge pada mannequin yang kami buat cenderung sangat sedikit sehingga hasil yang didapat tidak konsisten.
— — — — — — — — — — — — — —- — — SELESAI — —— — — — — — — — — — — — — — —
Terima kasih telah meluangkan waktu untuk membaca artikel ini. Semoga informasi yang disampaikan dapat bermanfaat dan memberikan pemahaman yang lebih baik mengenai algoritma Okay-Nearest Neighbors (KNN).
