Python Machine Learning – K-plus proches voisins (KNN)
Sur cette page, Infodewi.com collabore avec
Académie des sciences des données de NYCpour délivrer des contenus de formation numériques à nos étudiants.
KN
KNN est un algorithme d’apprentissage automatique (ML) simple et supervisé qui peut être utilisé pour des tâches de classification ou de régression – et est également fréquemment utilisé dans l’imputation des valeurs manquantes. Il est basé sur l’idée que les observations les plus proches d’un point de données donné sont les observations les plus « similaires » dans un ensemble de données, et nous pouvons donc classer les points imprévus en fonction des valeurs des points existants les plus proches. En choisissant Kl’utilisateur peut sélectionner le nombre d’observations proches à utiliser dans l’algorithme.
Ici, nous allons vous montrer comment implémenter l’algorithme KNN pour la classification et montrer comment différentes valeurs de K affecter les résultats.
Comment ça marche?
K est le nombre de voisins les plus proches à utiliser. Pour la classification, un vote à la majorité est utilisé pour déterminer à quelle classe une nouvelle observation doit appartenir. Des valeurs plus élevées de K sont souvent plus robustes aux valeurs aberrantes et produisent des limites de décision plus stables que de très petites valeurs (K=3 serait mieux que K=1ce qui pourrait produire des résultats indésirables.
Exemple
Commencez par visualiser quelques points de données :
importer matplotlib.pyplot en tant que plt
x = [4, 5, 10, 4, 3, 11, 14 , 8, 10, 12]
y = [21, 19, 24, 17, 16, 25, 24, 22, 21, 21]
cours = [0, 0, 1, 0, 0, 1, 1, 0, 1, 1]
plt.scatter(x, y, c=classes)
plt.show()
Résultat
Exemple d’exécution »
PUBLICITÉ
Maintenant, nous adaptons l’algorithme KNN avec K=1 :
from sklearn.neighbors import KNeighborsClassifier
données = liste(zip(x, y))
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(données, classes)
Et utilisez-le pour classer un nouveau point de données :
Exemple
nouveau_x = 8
nouveau_y = 21
nouveau_point = [(new_x, new_y)]
prédiction = knn.predict(nouveau_point)
plt.scatter(x + [new_x]y + [new_y]c=classes + [prediction[0]])
plt.text(x=new_x-1.7, y=new_y-0.7, s=f »nouveau point, classe : {prédiction[0]} »)
plt.show()
Résultat
Exemple d’exécution »
Maintenant on fait la même chose, mais avec une valeur K plus élevée qui change la prédiction :
Exemple
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(données, classes)
prédiction = knn.predict(nouveau_point)
plt.scatter(x + [new_x]y + [new_y]c=classes + [prediction[0]])
plt.text(x=new_x-1.7, y=new_y-0.7, s=f »nouveau point, classe : {prédiction[0]} »)
plt.show()
Résultat
Exemple d’exécution »
Exemple expliqué
Importez les modules dont vous avez besoin.
Vous pouvez en savoir plus sur le module Matplotlib dans notre « Tutoriel Matplotlib.
scikit-learn est une bibliothèque populaire pour l’apprentissage automatique en Python.
import matplotlib.pyplot as plt
from sklearn.neighbors import KNeighborsClassifier
Créez des tableaux qui ressemblent à des variables dans un ensemble de données. Nous avons deux caractéristiques d’entrée (x et y) puis une classe cible (class). Les entités en entrée qui sont pré-étiquetées avec notre classe cible seront utilisées pour prédire la classe des nouvelles données. Notez que bien que nous n’utilisions ici que deux caractéristiques d’entrée, cette méthode fonctionnera avec n’importe quel nombre de variables :
x = [4, 5, 10, 4, 3, 11, 14 , 8, 10, 12]
y = [21, 19, 24, 17, 16, 25, 24, 22, 21, 21]
classes = [0, 0, 1, 0, 0, 1, 1, 0, 1, 1]
Transformez les entités en entrée en un ensemble de points :
data = list(zip(x, y))
print(data)
Résultat:
[(4, 21), (5, 19), (10, 24), (4, 17), (3, 16), (11, 25), (14, 24), (8, 22), (10, 21), (12, 21)]
En utilisant les entités d’entrée et la classe cible, nous ajustons un modèle KNN sur le modèle en utilisant 1 plus proche voisin :
knn = KNeighborsClassifier(n_neighbors=1)
knn.fit(data, classes)
Ensuite, nous pouvons utiliser le même objet KNN pour prédire la classe de nouveaux points de données imprévus. Nous créons d’abord de nouvelles fonctionnalités x et y, puis appelons knn.predict() sur le nouveau point de données pour obtenir une classe de 0 ou 1 :
new_x = 8
new_y = 21
new_point = [(new_x, new_y)]
prediction = knn.predict(new_point)
print(prediction)
Résultat:
Lorsque nous traçons toutes les données avec le nouveau point et la nouvelle classe, nous pouvons voir qu’il a été étiqueté en bleu avec le 1 classe. L’annotation textuelle sert uniquement à mettre en évidence l’emplacement du nouveau point :
plt.scatter(x + [new_x], y + [new_y], c=classes + [prediction[0]])
plt.text(x=new_x-1.7, y=new_y-0.7, s=f"new point, class: {prediction[0]}")
plt.show()
Résultat:
Cependant, lorsque nous changeons le nombre de voisins à 5, le nombre de points utilisés pour classer notre nouveau point change. En conséquence, la classification du nouveau point fait de même :
knn = KNeighborsClassifier(n_neighbors=5)
knn.fit(data, classes)
prediction = knn.predict(new_point)
print(prediction)
Résultat:
Lorsque nous traçons la classe du nouveau point avec les anciens points, nous remarquons que la couleur a changé en fonction de l’étiquette de classe associée :
plt.scatter(x + [new_x], y + [new_y], c=classes + [prediction[0]])
plt.text(x=new_x-1.7, y=new_y-0.7, s=f"new point, class: {prediction[0]}")
plt.show()
Résultat:
#Python #Machine #Learning #Kplus #proches #voisins #KNN
