K Classification des voisins les plus proches, Classification : apprentissage automatique supervisé

k-Classification des voisins les plus proches

Définition et objectif

La classification

k-Nearest Neighbours (k-NN) est un algorithme d'apprentissage non paramétrique basé sur des instances utilisé dans l'apprentissage automatique pour classer les points de données en fonction des classes de leurs voisins les plus proches dans l'espace des fonctionnalités. . Il attribue une classe à un point de données en considérant les classes de ses k voisins les plus proches. L'objectif principal de la classification k-NN est de prédire la classe de nouveaux points de données en tirant parti de la similarité avec les données étiquetées existantes.

Objectifs clés :

• Classification : attribution de nouveaux points de données à l'une des classes prédéfinies en fonction du vote majoritaire ou du vote pondéré des voisins les plus proches.
• Estimation : Détermination de la probabilité qu'un point de données appartienne à une classe particulière.
• Comprendre les relations : identifier les points de données qui sont similaires dans l'espace des fonctionnalités.

Comment fonctionne la classification k-NN

1. Métrique de distance : L'algorithme utilise une métrique de distance (généralement la distance euclidienne) pour déterminer la « proximité » des points de données.

• Distance euclidienne :
  • d(p, q) = sqrt((p1 - q1)^2 + (p2 - q2)^2 + ... + (pn - qn)^2)
  • Mesure la distance en ligne droite entre deux points p et q dans un espace à n dimensions.

2. Choisir k : Le paramètre k précise le nombre de voisins les plus proches à prendre en compte pour prendre la décision de classification.

• Petit k : peut conduire à un surapprentissage, où le modèle est trop sensible aux données d'entraînement.
• K grand : peut conduire à un sous-ajustement, où le modèle est trop généralisé et peut manquer des modèles plus fins dans les données.

3. Vote majoritaire : La classe prédite pour un nouveau point de données est la classe la plus courante parmi ses k voisins les plus proches.

• Vote majoritaire :
  • Comptez le nombre d'occurrences de chaque classe parmi les k voisins.
  • Attribuez la classe avec le nombre le plus élevé au nouveau point de données.

4. Vote pondéré : Dans certains cas, les voisins sont pondérés en fonction de leur distance, les voisins les plus proches ayant plus d'influence sur le classement.

• Vote pondéré :
  • Pesez le vote de chaque voisin par l'inverse de sa distance.
  • Sommez les votes pondérés pour chaque classe.
  • Attribuez la classe avec la somme pondérée la plus élevée au nouveau point de données.

Concepts clés

1. Non paramétrique : k-NN est une méthode non paramétrique, ce qui signifie qu'elle ne fait aucune hypothèse sur la distribution sous-jacente des données. Cela le rend flexible dans la gestion de différents types de données.

2. Apprentissage basé sur l'instance : l'algorithme stocke l'intégralité de l'ensemble de données d'entraînement et effectue des prédictions basées sur les modèles locaux dans les données. Il est également connu comme un algorithme d'apprentissage « paresseux » car il retarde le traitement jusqu'à ce qu'une requête soit effectuée.

3. Calcul de distance : Le choix de la métrique de distance peut affecter considérablement les performances du modèle. Les mesures courantes incluent les distances euclidiennes, Manhattan et Minkowski.

4. Choix de k : La valeur de k est un hyperparamètre critique. La validation croisée est souvent utilisée pour déterminer la valeur optimale de k pour un ensemble de données donné.

Exemple de classification des k-voisins les plus proches (k-NN)

La classification k-Nearest Neighbours (k-NN) est un algorithme d'apprentissage non paramétrique basé sur des instances utilisé pour classer les points de données en fonction des classes de leurs voisins les plus proches. Cet exemple montre comment implémenter k-NN pour la classification multiclasse à l'aide de données synthétiques, évaluer les performances du modèle et visualiser la limite de décision pour trois classes.

Exemple de code Python

1. Importer des bibliothèques

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

Ce bloc importe les bibliothèques nécessaires à la manipulation des données, au traçage et à l'apprentissage automatique.

2. Générer des exemples de données avec 3 classes

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))

Ce bloc génère des données synthétiques pour trois classes situées dans différentes régions de l'espace des fonctionnalités.

3. Diviser l'ensemble de données

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

Ce bloc divise l'ensemble de données en ensembles de formation et de test pour l'évaluation du modèle.

4. Créer et former le classificateur k-NN

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

Ce bloc initialise le classificateur k-NN avec le nombre spécifié de voisins et l'entraîne à l'aide de l'ensemble de données d'entraînement.

5. Faire des pronostics

y_pred = knn_classifier.predict(X_test)

Ce bloc utilise le modèle entraîné pour faire des prédictions sur l'ensemble de test.

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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!