K Klasifikasi Jiran Terdekat, Klasifikasi: Pembelajaran Mesin Terselia

k-Pengkelasan Jiran Terdekat

Definisi dan Tujuan

Klasifikasi

k-Nearest Neighbors (k-NN) ialah algoritma pembelajaran berasaskan contoh bukan parametrik yang digunakan dalam pembelajaran mesin untuk mengelaskan titik data berdasarkan kelas jiran terdekat mereka dalam ruang ciri . Ia memberikan kelas kepada titik data dengan mempertimbangkan kelas k jiran terdekatnya. Tujuan utama pengelasan k-NN adalah untuk meramal kelas titik data baharu dengan memanfaatkan persamaan dengan data berlabel sedia ada.

Objektif Utama:

• Klasifikasi: Menetapkan mata data baharu kepada salah satu kelas yang dipratentukan berdasarkan undian majoriti atau undi wajaran jiran terdekat.
• Anggaran: Menentukan kemungkinan titik data kepunyaan kelas tertentu.
• Memahami Perhubungan: Mengenal pasti titik data yang serupa dalam ruang ciri.

Bagaimana Klasifikasi k-NN Berfungsi

1. Metrik Jarak: Algoritma menggunakan metrik jarak (biasanya jarak Euclidean) untuk menentukan "kedekatan" titik data.

• Jarak Euclidean:
  • d(p, q) = sqrt((p1 - q1)^2 + (p2 - q2)^2 + ... + (pn - qn)^2)
  • Mengukur jarak garis lurus antara dua titik p dan q dalam ruang dimensi-n.

2. Memilih k: Parameter k menentukan bilangan jiran terdekat untuk dipertimbangkan untuk membuat keputusan pengelasan.

• K kecil: Boleh menyebabkan pemasangan berlebihan, di mana model terlalu sensitif kepada data latihan.
• K besar: Boleh menyebabkan ketidaksesuaian, di mana model terlalu umum dan mungkin terlepas corak yang lebih halus dalam data.

3. Pengundian Majoriti: Kelas yang diramalkan untuk titik data baharu ialah kelas yang paling biasa di kalangan jiran terdekatnya.

• Undi Majoriti:
  • Kira bilangan kejadian setiap kelas antara k jiran.
  • Tugaskan kelas dengan kiraan tertinggi kepada titik data baharu.

4. Pengundian Berwajaran: Dalam sesetengah kes, jiran ditimbang mengikut jarak mereka, dengan jiran yang lebih dekat mempunyai pengaruh yang lebih pada klasifikasi.

• Undi Wajaran:
  • Timbang undi setiap jiran mengikut songsangan jaraknya.
  • Jumlah undian wajaran bagi setiap kelas.
  • Tugaskan kelas dengan jumlah wajaran tertinggi kepada titik data baharu.

Konsep Utama

1. Bukan Parametrik: k-NN ialah kaedah bukan parametrik, bermakna ia tidak membuat andaian tentang pengedaran asas data. Ini menjadikannya fleksibel dalam mengendalikan pelbagai jenis data.

2. Pembelajaran Berasaskan Instance: Algoritma menyimpan keseluruhan set data latihan dan membuat ramalan berdasarkan corak setempat dalam data. Ia juga dikenali sebagai algoritma pembelajaran "malas" kerana ia menangguhkan pemprosesan sehingga pertanyaan dibuat.

3. Pengiraan Jarak: Pilihan metrik jarak boleh menjejaskan prestasi model dengan ketara. Metrik biasa termasuk jarak Euclidean, Manhattan dan Minkowski.

4. Pilihan k: Nilai k ialah hiperparameter kritikal. Pengesahan silang selalunya digunakan untuk menentukan nilai optimum k untuk set data tertentu.

k-Nearest Neibours (k-NN) Contoh Klasifikasi

Klasifikasi k-Nearest Neighbors (k-NN) ialah algoritma pembelajaran berasaskan contoh bukan parametrik yang digunakan untuk mengelaskan titik data berdasarkan kelas jiran terdekat mereka. Contoh ini menunjukkan cara melaksanakan k-NN untuk klasifikasi berbilang kelas menggunakan data sintetik, menilai prestasi model dan menggambarkan sempadan keputusan untuk tiga kelas.

Contoh Kod Python

1. Import Perpustakaan

import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, classification_report

Blok ini mengimport pustaka yang diperlukan untuk manipulasi data, plot dan pembelajaran mesin.

2. Hasilkan Data Contoh dengan 3 Kelas

np.random.seed(42)  # For reproducibility
n_samples = 300

# Class 0: Cluster at the top-left corner
X0 = np.random.randn(n_samples // 3, 2) * 0.5 + [-2, 2]

# Class 1: Cluster at the top-right corner
X1 = np.random.randn(n_samples // 3, 2) * 0.5 + [2, 2]

# Class 2: Cluster at the bottom-center
X2 = np.random.randn(n_samples // 3, 2) * 0.5 + [0, -2]

# Combine all classes
X = np.vstack((X0, X1, X2))
y = np.array([0] * (n_samples // 3) + [1] * (n_samples // 3) + [2] * (n_samples // 3))

Blok ini menjana data sintetik untuk tiga kelas yang terletak di kawasan ruang ciri yang berbeza.

3. Pisahkan Set Data

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

Blok ini membahagikan set data kepada set latihan dan ujian untuk penilaian model.

4. Cipta dan Latih Pengelas k-NN

k = 5  # Number of neighbors
knn_classifier = KNeighborsClassifier(n_neighbors=k)
knn_classifier.fit(X_train, y_train)

Blok ini memulakan pengelas k-NN dengan bilangan jiran yang ditentukan dan melatihnya menggunakan set data latihan.

5. Buat Ramalan

y_pred = knn_classifier.predict(X_test)

Blok ini menggunakan model terlatih untuk membuat ramalan pada set ujian.

6. Evaluate the Model

accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy:.2f}")
print("\nClassification Report:")
print(classification_report(y_test, y_pred))

Output:

Accuracy: 1.00

Classification Report:
              precision    recall  f1-score   support

           0       1.00      1.00      1.00        22
           1       1.00      1.00      1.00        16
           2       1.00      1.00      1.00        22

    accuracy                           1.00        60
   macro avg       1.00      1.00      1.00        60
weighted avg       1.00      1.00      1.00        60

This block calculates and prints the accuracy and classification report, providing insights into the model's performance.

7. Visualize the Decision Boundary

h = 0.02  # Step size in the mesh
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

Z = knn_classifier.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

plt.figure(figsize=(12, 8))
plt.contourf(xx, yy, Z, cmap=plt.cm.RdYlBu, alpha=0.8)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.RdYlBu, edgecolors='black')
plt.xlabel('Feature 1')
plt.ylabel('Feature 2')
plt.title(f'k-NN Classification (k={k})')
plt.colorbar()
plt.show()

This block visualizes the decision boundaries created by the k-NN classifier, illustrating how the model separates the three classes in the feature space.

Output:

This structured approach demonstrates how to implement and evaluate k-NN for multiclass classification tasks, providing a clear understanding of its capabilities and the effectiveness of visualizing decision boundaries.

Atas ialah kandungan terperinci K Klasifikasi Jiran Terdekat, Klasifikasi: Pembelajaran Mesin Terselia. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!