Scikit Learn - Apprentissage KNN

k-NN (k-Nearest Neighbor), l'un des algorithmes d'apprentissage automatique les plus simples, est non paramétrique et paresseux par nature. Non paramétrique signifie qu'il n'y a pas d'hypothèse pour la distribution de données sous-jacente, c'est-à-dire que la structure du modèle est déterminée à partir de l'ensemble de données. L'apprentissage paresseux ou basé sur une instance signifie que dans le cadre de la génération de modèle, il ne nécessite aucun point de données d'entraînement et des données d'entraînement entières sont utilisées dans la phase de test.

L'algorithme k-NN comprend les deux étapes suivantes -

Étape 1

Dans cette étape, il calcule et stocke les k voisins les plus proches pour chaque échantillon de l'ensemble d'apprentissage.

Étape 2

Dans cette étape, pour un échantillon non étiqueté, il récupère les k voisins les plus proches de l'ensemble de données. Ensuite, parmi ces k voisins les plus proches, il prédit la classe par le vote (la classe à voix majoritaire l'emporte).

Le module, sklearn.neighbors qui implémente l'algorithme des k-plus proches voisins, fournit la fonctionnalité pour unsupervised aussi bien que supervised méthodes d'apprentissage basées sur les voisins.

Les plus proches voisins non supervisés implémentent différents algorithmes (BallTree, KDTree ou Brute Force) pour trouver le ou les voisins les plus proches pour chaque échantillon. Cette version non supervisée n'est fondamentalement que l'étape 1, qui est discutée ci-dessus, et le fondement de nombreux algorithmes (KNN et K-means étant le plus célèbre) qui nécessitent la recherche de voisins. En termes simples, il s'agit d'un apprenant non supervisé pour la mise en œuvre de recherches de voisins.

D'autre part, l'apprentissage supervisé basé sur les voisins est utilisé pour la classification ainsi que la régression.

Apprentissage KNN non supervisé

Comme discuté, il existe de nombreux algorithmes tels que KNN et K-Means qui nécessitent des recherches de voisins les plus proches. C'est pourquoi Scikit-learn a décidé de mettre en œuvre la partie de recherche de voisins comme son propre «apprenant». La raison pour laquelle la recherche de voisins est un apprenant distinct est que le calcul de toutes les distances par paires pour trouver un voisin le plus proche n'est évidemment pas très efficace. Voyons le module utilisé par Sklearn pour implémenter l'apprentissage du voisin le plus proche non supervisé avec un exemple.

Module Scikit-learn

sklearn.neighbors.NearestNeighborsest le module utilisé pour implémenter l'apprentissage non supervisé du voisin le plus proche. Il utilise des algorithmes spécifiques du voisin le plus proche nommé BallTree, KDTree ou Brute Force. En d'autres termes, il agit comme une interface uniforme avec ces trois algorithmes.

Paramètres

Le tableau suivant comprend les paramètres utilisés par NearestNeighbors module -

Sr.Non Paramètre et description
1

n_neighbors - int, facultatif

Le nombre de voisins à obtenir. La valeur par défaut est 5.
2

radius - flotteur, en option

Il limite la distance des voisins aux retours. La valeur par défaut est 1.0.
3

algorithm - {'auto', 'ball_tree', 'kd_tree', 'brute'}, facultatif

Ce paramètre prendra l'algorithme (BallTree, KDTree ou Brute-force) que vous souhaitez utiliser pour calculer les voisins les plus proches. Si vous fournissez «auto», il tentera de décider de l'algorithme le plus approprié en fonction des valeurs transmises à la méthode fit.
4

leaf_size - int, facultatif

Cela peut affecter la vitesse de construction et de requête ainsi que la mémoire nécessaire pour stocker l'arborescence. Il est transmis à BallTree ou KDTree. Bien que la valeur optimale dépende de la nature du problème, sa valeur par défaut est 30.
5

metric - chaîne ou appelable

C'est la métrique à utiliser pour le calcul de la distance entre les points. Nous pouvons le passer sous forme de chaîne ou de fonction appelable. En cas de fonction appelable, la métrique est appelée sur chaque paire de lignes et la valeur résultante est enregistrée. C'est moins efficace que de transmettre le nom de la métrique sous forme de chaîne.

Nous pouvons choisir entre la métrique scikit-learn ou scipy.spatial.distance. les valeurs valides sont les suivantes -

Scikit-learn - ['cosinus', 'manhattan', 'euclidien', 'l1', 'l2', 'cityblock']

Scipy.spatial.distance -

['braycurtis', 'canberra', 'chebyshev', 'dice', 'hamming', 'jaccard', 'correlation', 'kulsinski', 'mahalanobis', 'minkowski', 'rogerstanimoto', 'russellrao', ' sokalmicheme ',' sokalsneath ',' seuclidean ',' sqeuclidean ',' yule '].

La métrique par défaut est «Minkowski».
6

P - entier, facultatif

C'est le paramètre de la métrique de Minkowski. La valeur par défaut est 2, ce qui équivaut à utiliser Euclidean_distance (l2).
sept

metric_params - dict, facultatif

Il s'agit des arguments de mots clés supplémentaires pour la fonction métrique. La valeur par défaut est Aucun.
8

N_jobs - int ou None, facultatif

Il redéfinit le nombre de travaux parallèles à exécuter pour la recherche de voisins. La valeur par défaut est Aucun.

Implementation Example

L'exemple ci-dessous trouvera les voisins les plus proches entre deux ensembles de données en utilisant le sklearn.neighbors.NearestNeighbors module.

Tout d'abord, nous devons importer le module et les packages requis -

from sklearn.neighbors import NearestNeighbors
import numpy as np

Maintenant, après avoir importé les packages, définissez les ensembles de données entre nous voulons trouver les voisins les plus proches -

Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])

Ensuite, appliquez l'algorithme d'apprentissage non supervisé, comme suit -

nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm = 'ball_tree')

Ensuite, ajustez le modèle avec l'ensemble de données d'entrée.

nrst_neigh.fit(Input_data)

Maintenant, trouvez les K-voisins de l'ensemble de données. Il renverra les indices et les distances des voisins de chaque point.

distances, indices = nbrs.kneighbors(Input_data)
indices

Output

array(
   [
      [0, 1, 3],
      [1, 2, 0],
      [2, 1, 0],
      [3, 4, 0],
      [4, 5, 3],
      [5, 6, 4],
      [6, 5, 4]
   ], dtype = int64
)
distances

Output

array(
   [
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712],
      [0. , 1.41421356, 2.23606798],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 1.41421356],
      [0. , 1.41421356, 2.82842712]
   ]
)

La sortie ci-dessus montre que le plus proche voisin de chaque point est le point lui-même, c'est-à-dire à zéro. C'est parce que l'ensemble de requêtes correspond à l'ensemble d'apprentissage.

Example

Nous pouvons également montrer une connexion entre des points voisins en produisant un graphe clairsemé comme suit -

nrst_neigh.kneighbors_graph(Input_data).toarray()

Output

array(
   [
      [1., 1., 0., 1., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 1., 1., 0., 0., 0., 0.],
      [1., 0., 0., 1., 1., 0., 0.],
      [0., 0., 0., 1., 1., 1., 0.],
      [0., 0., 0., 0., 1., 1., 1.],
      [0., 0., 0., 0., 1., 1., 1.]
   ]
)

Une fois que nous ajustons le non supervisé NearestNeighbors model, les données seront stockées dans une structure de données basée sur la valeur définie pour l'argument ‘algorithm’. Après cela, nous pouvons utiliser cet apprenant non supervisékneighbors dans un modèle qui nécessite des recherches de voisins.

Complete working/executable program

from sklearn.neighbors import NearestNeighbors
import numpy as np
Input_data = np.array([[-1, 1], [-2, 2], [-3, 3], [1, 2], [2, 3], [3, 4],[4, 5]])
nrst_neigh = NearestNeighbors(n_neighbors = 3, algorithm='ball_tree')
nrst_neigh.fit(Input_data)
distances, indices = nbrs.kneighbors(Input_data)
indices
distances
nrst_neigh.kneighbors_graph(Input_data).toarray()

Apprentissage KNN supervisé

L'apprentissage supervisé basé sur les voisins est utilisé pour suivre -

  • Classification, pour les données avec des étiquettes discrètes
  • Régression, pour les données avec des étiquettes continues.

Classificateur de voisin le plus proche

Nous pouvons comprendre la classification basée sur les voisins à l'aide de deux caractéristiques suivantes -

  • Il est calculé à partir d'un vote à la majorité simple des voisins les plus proches de chaque point.
  • Il stocke simplement des instances des données d'entraînement, c'est pourquoi il s'agit d'un type d'apprentissage non généralisant.

Modules Scikit-learn

Les éléments suivants sont les deux types différents de classificateurs de voisins les plus proches utilisés par scikit-learn -

S.No. Classificateurs et description
1. KNeighborsClassifier

Le K dans le nom de ce classificateur représente les k voisins les plus proches, où k est une valeur entière spécifiée par l'utilisateur. Par conséquent, comme son nom l'indique, ce classificateur implémente l'apprentissage basé sur les k voisins les plus proches. Le choix de la valeur de k dépend des données.
2. RadiusNeighborsClassifier

Le rayon dans le nom de ce classificateur représente les voisins les plus proches dans un rayon spécifié r, où r est une valeur à virgule flottante spécifiée par l'utilisateur. Par conséquent, comme son nom l'indique, ce classificateur met en œuvre un apprentissage basé sur le nombre de voisins dans un rayon fixe r de chaque point d'apprentissage.

Régresseur de voisin le plus proche

Il est utilisé dans les cas où les étiquettes de données sont de nature continue. Les étiquettes de données attribuées sont calculées sur la base de la moyenne des étiquettes de ses voisins les plus proches.

Les éléments suivants sont les deux types différents de régresseurs voisins les plus proches utilisés par scikit-learn -

KNeighboursRegressor

Le K au nom de ce régresseur représente les k voisins les plus proches, où k est un integer valuespécifié par l'utilisateur. Par conséquent, comme son nom l'indique, ce régresseur implémente l'apprentissage basé sur les k voisins les plus proches. Le choix de la valeur de k dépend des données. Comprenons-le davantage à l'aide d'un exemple d'implémentation.

Les éléments suivants sont les deux types différents de régresseurs voisins les plus proches utilisés par scikit-learn -

Exemple d'implémentation

Dans cet exemple, nous allons implémenter KNN sur un ensemble de données nommé Iris Flower à l'aide de scikit-learn KNeighborsRegressor.

Tout d'abord, importez le jeu de données iris comme suit -

from sklearn.datasets import load_iris
iris = load_iris()

Maintenant, nous devons diviser les données en données d'entraînement et de test. Nous utiliserons Sklearntrain_test_split fonction pour diviser les données dans le rapport de 70 (données d'entraînement) et 20 (données de test) -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)

Ensuite, nous ferons la mise à l'échelle des données à l'aide du module de pré-traitement Sklearn comme suit -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Ensuite, importez le KNeighborsRegressor classe de Sklearn et fournissez la valeur des voisins comme suit.

Exemple

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 8)
knnr.fit(X_train, y_train)

Production

KNeighborsRegressor(
   algorithm = 'auto', leaf_size = 30, metric = 'minkowski',
   metric_params = None, n_jobs = None, n_neighbors = 8, p = 2,
   weights = 'uniform'
)

Exemple

Maintenant, nous pouvons trouver la MSE (erreur quadratique moyenne) comme suit -

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

Production

The MSE is: 4.4333349609375

Exemple

Maintenant, utilisez-le pour prédire la valeur comme suit -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors = 3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

Production

[0.66666667]

Programme complet de travail / exécutable

from sklearn.datasets import load_iris
iris = load_iris()
X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

import numpy as np
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=8)
knnr.fit(X_train, y_train)

print ("The MSE is:",format(np.power(y-knnr.predict(X),4).mean()))

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import KNeighborsRegressor
knnr = KNeighborsRegressor(n_neighbors=3)
knnr.fit(X, y)
print(knnr.predict([[2.5]]))

RadiusVoisinsRégresseur

Le rayon dans le nom de ce régresseur représente les voisins les plus proches dans un rayon spécifié r, où r est une valeur à virgule flottante spécifiée par l'utilisateur. Par conséquent, comme son nom l'indique, ce régresseur implémente l'apprentissage basé sur le nombre de voisins dans un rayon fixe r de chaque point d'apprentissage. Comprenons-le davantage avec l'aide si un exemple d'implémentation -

Exemple d'implémentation

Dans cet exemple, nous allons implémenter KNN sur un ensemble de données nommé Iris Flower à l'aide de scikit-learn RadiusNeighborsRegressor -

Tout d'abord, importez le jeu de données iris comme suit -

from sklearn.datasets import load_iris
iris = load_iris()

Maintenant, nous devons diviser les données en données d'entraînement et de test. Nous utiliserons la fonction Sklearn train_test_split pour diviser les données en un rapport de 70 (données d'entraînement) et 20 (données de test) -

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.20)

Ensuite, nous ferons la mise à l'échelle des données à l'aide du module de pré-traitement Sklearn comme suit -

from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)

Ensuite, importez le RadiusneighborsRegressor classe de Sklearn et fournissez la valeur du rayon comme suit -

import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X_train, y_train)

Exemple

Maintenant, nous pouvons trouver la MSE (erreur quadratique moyenne) comme suit -

print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))

Production

The MSE is: The MSE is: 5.666666666666667

Exemple

Maintenant, utilisez-le pour prédire la valeur comme suit -

X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius=1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))

Production

[1.]

Programme complet de travail / exécutable

from sklearn.datasets import load_iris

iris = load_iris()

X = iris.data[:, :4]
y = iris.target
from sklearn.model_selection import train_test_split
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.20)
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()
scaler.fit(X_train)
X_train = scaler.transform(X_train)
X_test = scaler.transform(X_test)
import numpy as np
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X_train, y_train)
print ("The MSE is:",format(np.power(y-knnr_r.predict(X),4).mean()))
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
from sklearn.neighbors import RadiusNeighborsRegressor
knnr_r = RadiusNeighborsRegressor(radius = 1)
knnr_r.fit(X, y)
print(knnr_r.predict([[2.5]]))