K-Nearest Neighbors (KNN) en Python

Les k-plus proches voisins (kNN) sont une technique d'apprentissage automatique supervisé qui peut être utilisée pour des tâches de classification et de régression. Je considère le KNN comme un algorithme qui provient de la vie réelle. Les gens ont tendance à être influencés par les personnes qui les entourent.

L'idée derrière l'algorithme des K plus proches voisins

Notre comportement est façonné par les compagnons avec lesquels nous avons grandi. Nos parents façonnent également nos personnalités de différentes manières. Si vous grandissez parmi des gens qui aiment le sport, il est très probable que vous finissiez par aimer le sport. Il y a bien sûr des exceptions. Le KNN fonctionne de manière similaire.

1. Si vous avez un ami proche et passez la plupart de votre temps avec lui/elle, vous finirez par avoir des intérêts similaires et aimer les mêmes choses. C'est le kNN avec k=1.
2. Si vous traînez constamment avec un groupe de 5 personnes, chacune d'entre elles a un impact sur votre comportement et vous finirez par devenir la moyenne des 5. C'est le kNN avec k=5.

Le classificateur kNN identifie la classe d'un point de données en utilisant le principe de vote majoritaire. Si k est fixé à 5, les classes des 5 points les plus proches sont examinées. La prédiction est faite en fonction de la classe prédominante. De même, la régression kNN prend la valeur moyenne des 5 emplacements les plus proches.

Assiste-t-on à des personnes qui sont proches, mais comment les points de données sont-ils considérés comme proches ? La distance entre les points de données est mesurée. Il existe diverses techniques pour estimer la distance. La distance euclidienne (distance de Minkowski avec p=2) est l'une des mesures de distance les plus régulièrement utilisées. Le graphique ci-dessous explique comment calculer la distance euclidienne entre deux points dans un espace à 2 dimensions. Elle est déterminée en utilisant le carré de la différence entre les coordonnées x et y des emplacements.

Mise en œuvre de l'algorithme KNN en Python

Entrons maintenant dans l'implémentation de KNN en Python. Nous passerons en revue les étapes pour vous aider à décomposer le code et à mieux le comprendre.

1. Importation des modules

import numpy as np
import pandas as pd

import matplotlib.pyplot as plt

from sklearn.datasets import make_blobs
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split

2. Création de l'ensemble de données

Scikit-learn dispose de nombreux outils pour créer des ensembles de données synthétiques, qui sont excellents pour tester les algorithmes d'apprentissage automatique. Je vais utiliser la méthode make_blobs.

X, y = make_blobs(n_samples = 500, n_features = 2, centers = 4,cluster_std = 1.5, random_state = 4)

Ce code génère un ensemble de données de 500 échantillons répartis en quatre classes avec un total de deux caractéristiques. En utilisant des paramètres associés, vous pouvez rapidement modifier le nombre d'échantillons, de caractéristiques et de classes. Nous pouvons également changer la distribution de chaque groupe (ou classe).

3. Visualisez le jeu de données

plt.style.use('seaborn')
plt.figure(figsize = (10,10))
plt.scatter(X[:,0], X[:,1], c=y, marker= '*',s=100,edgecolors='black')
plt.show()

4. Division des données en ensembles d'entraînement et de test

Il est essentiel de diviser un ensemble de données en ensembles d'entraînement et de test pour chaque méthode d'apprentissage supervisé. Nous entraînons d'abord le modèle, puis nous le testons sur différentes parties de l'ensemble de données. Si nous ne séparons pas les données, nous testons simplement le modèle avec des données qu'il connaît déjà. En utilisant la méthode train_test_split, nous pouvons facilement séparer les tests.

X_train, X_test, y_train, y_test = train_test_split(X, y, random_state = 0)

Avec les options de taille d'entraînement et de taille de test, nous pouvons déterminer quelle quantité des données d'origine est utilisée pour les ensembles d'entraînement et de test, respectivement. La séparation par défaut est de 75 % pour l'ensemble d'entraînement et de 25 % pour l'ensemble de test.

5. Mise en œuvre du classificateur KNN

Après cela, nous allons créer un objet classificateur kNN. Je développe deux classificateurs avec des valeurs de k de 1 et 5 pour démontrer la pertinence de la valeur de k. Les modèles sont ensuite entraînés à l'aide d'un ensemble d'entraînement. La valeur de k est choisie en utilisant le paramètre n_neighbors. Il n'est pas nécessaire de le spécifier explicitement car la valeur par défaut est 5.

knn5 = KNeighborsClassifier(n_neighbors = 5)
knn1 = KNeighborsClassifier(n_neighbors=1)

6. Prédictions pour les classificateurs KNN

Ensuite, dans l'ensemble de test, nous prédisons les valeurs cibles et les comparons aux valeurs réelles.

knn5.fit(X_train, y_train)
knn1.fit(X_train, y_train)

y_pred_5 = knn5.predict(X_test)
y_pred_1 = knn1.predict(X_test)

7. Prédire la précision pour les deux valeurs de k

from sklearn.metrics import accuracy_score
print("Accuracy with k=5", accuracy_score(y_test, y_pred_5)*100)
print("Accuracy with k=1", accuracy_score(y_test, y_pred_1)*100)

La précision des valeurs de k est la suivante :

Accuracy with k=5 93.60000000000001
Accuracy with k=1 90.4

8. Visualiser les prédictions

Voyons l'ensemble de test et les valeurs prédites avec k=5 et k=1 afin de voir l'influence des valeurs de k.

plt.figure(figsize = (15,5))
plt.subplot(1,2,1)
plt.scatter(X_test[:,0], X_test[:,1], c=y_pred_5, marker= '*', s=100,edgecolors='black')
plt.title("Predicted values with k=5", fontsize=20)

plt.subplot(1,2,2)
plt.scatter(X_test[:,0], X_test[:,1], c=y_pred_1, marker= '*', s=100,edgecolors='black')
plt.title("Predicted values with k=1", fontsize=20)
plt.show()

Comment trouver la meilleure valeur de k pour implémenter KNN

1. k=1 : Le modèle est trop étroit et n'est pas correctement généralisé. Il a également une grande sensibilité au bruit. Le modèle prédit des points de données nouveaux, auparavant inconnus, avec un haut degré de précision sur un ensemble d'entraînement, mais il est un mauvais prédicteur sur des points de données frais, auparavant non vus. En conséquence, nous sommes susceptibles d'avoir un modèle surajusté.
2. k=100 : Le modèle est trop général et peu fiable à la fois sur les ensembles d'entraînement et de test. L'underfitting est le terme utilisé pour décrire cette situation.

Limitations de l'algorithme KNN

KNN est un algorithme simple à comprendre. Il ne s'appuie sur aucun modèle interne d'apprentissage automatique pour générer des prédictions. KNN est une méthode de classification qui a simplement besoin de connaître le nombre de catégories existantes pour fonctionner (une ou plusieurs). Cela signifie qu'il peut rapidement évaluer si une nouvelle catégorie doit être ajoutée sans avoir à savoir combien d'autres il y a.

L'inconvénient de cette simplicité est qu'elle ne peut pas anticiper des choses inhabituelles (comme de nouvelles maladies), ce que KNN ne peut pas accomplir car il ne sait pas quelle serait la prévalence d'un élément rare dans une population saine.

Bien que le KNN obtienne une grande précision sur l'ensemble de test, il est plus lent et plus coûteux en termes de temps et de mémoire. Il nécessite une quantité considérable de mémoire pour stocker l'ensemble de données d'entraînement entier pour la prédiction. De plus, comme la distance euclidienne est très sensible aux grandeurs, les caractéristiques dans l'ensemble de données avec de grandes grandeurs l'emporteront toujours sur celles avec de petites grandeurs.

Enfin, en tenant compte de tout ce que nous avons discuté jusqu'à présent, nous devons garder à l'esprit que KNN n'est pas idéal pour les ensembles de données de grande dimension.

Conclusion

Espérons que vous avez maintenant une meilleure compréhension de l'algorithme KNN. Nous avons examiné une variété d'idées sur la façon dont KNN sauvegarde l'ensemble des données pour générer des prédictions.

KNN est l'un des plusieurs algorithmes d'apprentissage paresseux qui n'utilisent pas de modèle d'apprentissage pour faire des prédictions. En moyennant la similarité entre une observation entrante et les données déjà disponibles, KNN crée des prédictions à la volée (juste à temps).

Merci de votre lecture !