Scikit Learn - KNN Learning

k-NN (k-vizinho mais próximo), um dos algoritmos de aprendizado de máquina mais simples, é não paramétrico e preguiçoso por natureza. Não paramétrico significa que não há suposição para a distribuição de dados subjacente, ou seja, a estrutura do modelo é determinada a partir do conjunto de dados. Aprendizagem lenta ou baseada em instância significa que, para fins de geração de modelo, não requer nenhum ponto de dados de treinamento e todos os dados de treinamento são usados ​​na fase de teste.

O algoritmo k-NN consiste nas duas etapas a seguir -

Passo 1

Nesta etapa, ele calcula e armazena os k vizinhos mais próximos para cada amostra no conjunto de treinamento.

Passo 2

Nesta etapa, para uma amostra não rotulada, ele recupera os k vizinhos mais próximos do conjunto de dados. Então, entre esses k-vizinhos mais próximos, ele prevê a classe por meio da votação (a classe com maioria de votos vence).

O módulo, sklearn.neighbors que implementa o algoritmo de vizinhos k-mais próximos, fornece a funcionalidade para unsupervised assim como supervised métodos de aprendizagem baseados em vizinhos.

Os vizinhos mais próximos não supervisionados implementam algoritmos diferentes (BallTree, KDTree ou Brute Force) para encontrar o (s) vizinho (s) mais próximo (s) para cada amostra. Esta versão não supervisionada é basicamente apenas o passo 1, que é discutido acima, e a base de muitos algoritmos (KNN e K-means sendo o famoso) que requerem a busca de vizinho. Em palavras simples, é o aluno não supervisionado para a implementação de pesquisas de vizinhos.

Por outro lado, a aprendizagem supervisionada baseada em vizinhos é usada tanto para classificação quanto para regressão.

Aprendizagem KNN Não Supervisionada

Conforme discutido, existem muitos algoritmos como KNN e K-Means que requerem pesquisas de vizinho mais próximo. É por isso que o Scikit-learn decidiu implementar a parte de pesquisa de vizinhos como seu próprio “aprendiz”. A razão por trás de fazer a pesquisa de vizinho como um aluno separado é que calcular todas as distâncias entre pares para encontrar um vizinho mais próximo obviamente não é muito eficiente. Vamos ver o módulo usado pelo Sklearn para implementar o aprendizado do vizinho mais próximo não supervisionado junto com o exemplo.

Módulo Scikit-learn

sklearn.neighbors.NearestNeighborsé o módulo usado para implementar o aprendizado do vizinho mais próximo não supervisionado. Ele usa algoritmos de vizinho mais próximo específicos chamados BallTree, KDTree ou Brute Force. Em outras palavras, ele atua como uma interface uniforme para esses três algoritmos.

Parâmetros

A tabela a seguir consiste nos parâmetros usados ​​por NearestNeighbors módulo -

Sr. Não Parâmetro e Descrição
1

n_neighbors - int, opcional

O número de vizinhos a serem obtidos. O valor padrão é 5.
2

radius - float, opcional

Limita a distância dos vizinhos aos retornos. O valor padrão é 1.0.
3

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

Este parâmetro pegará o algoritmo (BallTree, KDTree ou Brute-force) que você deseja usar para calcular os vizinhos mais próximos. Se você fornecer 'auto', ele tentará decidir o algoritmo mais apropriado com base nos valores passados ​​para o método de ajuste.
4

leaf_size - int, opcional

Isso pode afetar a velocidade da construção e da consulta, bem como a memória necessária para armazenar a árvore. É passado para BallTree ou KDTree. Embora o valor ideal dependa da natureza do problema, seu valor padrão é 30.
5

metric - string ou chamável

É a métrica a ser usada para cálculo de distância entre pontos. Podemos passá-lo como uma string ou função que pode ser chamada. No caso de função chamável, a métrica é chamada em cada par de linhas e o valor resultante é registrado. É menos eficiente do que passar o nome da métrica como uma string.

Podemos escolher a métrica de scikit-learn ou scipy.spatial.distance. os valores válidos são os seguintes -

Scikit-learn - ['cosine', 'manhattan', 'Euclidean', 'l1', 'l2', 'cityblock']

Scipy.spatial.distance -

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

A métrica padrão é 'Minkowski'.
6

P - inteiro, opcional

É o parâmetro para a métrica de Minkowski. O valor padrão é 2, que é equivalente a usar distância_euclidiana (l2).
7

metric_params - dict, opcional

Estes são os argumentos de palavra-chave adicionais para a função métrica. O valor padrão é nenhum.
8

N_jobs - int ou nenhum, opcional

Ele redefine o número de trabalhos paralelos a serem executados para pesquisa de vizinho. O valor padrão é nenhum.

Implementation Example

O exemplo abaixo encontrará os vizinhos mais próximos entre dois conjuntos de dados usando o sklearn.neighbors.NearestNeighbors módulo.

Primeiro, precisamos importar o módulo e os pacotes necessários -

from sklearn.neighbors import NearestNeighbors
import numpy as np

Agora, depois de importar os pacotes, defina os conjuntos de dados entre os quais queremos encontrar os vizinhos mais próximos -

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

Em seguida, aplique o algoritmo de aprendizado não supervisionado, como segue -

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

Em seguida, ajuste o modelo com o conjunto de dados de entrada.

nrst_neigh.fit(Input_data)

Agora, encontre os K-vizinhos do conjunto de dados. Ele retornará os índices e distâncias dos vizinhos de cada ponto.

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

A saída acima mostra que o vizinho mais próximo de cada ponto é o próprio ponto, ou seja, em zero. É porque o conjunto de consultas corresponde ao conjunto de treinamento.

Example

Também podemos mostrar uma conexão entre pontos vizinhos, produzindo um gráfico esparso como segue -

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

Uma vez que ajustamos o não supervisionado NearestNeighbors modelo, os dados serão armazenados em uma estrutura de dados com base no valor definido para o argumento ‘algorithm’. Depois disso, podemos usar este aluno não supervisionadokneighbors em um modelo que requer pesquisas vizinhas.

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

Aprendizagem KNN Supervisionada

A aprendizagem supervisionada baseada em vizinhos é usada para seguir -

  • Classificação, para os dados com rótulos discretos
  • Regressão, para os dados com rótulos contínuos.

Classificador de Vizinho Mais Próximo

Podemos entender a classificação baseada em vizinhos com a ajuda das seguintes duas características -

  • É calculado a partir de uma votação por maioria simples dos vizinhos mais próximos de cada ponto.
  • Ele simplesmente armazena instâncias dos dados de treinamento, por isso é um tipo de aprendizado não generalizante.

Módulos de aprendizagem Scikit

A seguir estão os dois tipos diferentes de classificadores de vizinho mais próximo usados ​​pelo scikit-learn -

S.No. Classificadores e descrição
1 KNeighboursClassifier

O K no nome deste classificador representa os k vizinhos mais próximos, onde k é um valor inteiro especificado pelo usuário. Portanto, como o nome sugere, esse classificador implementa o aprendizado com base nos k vizinhos mais próximos. A escolha do valor de k depende dos dados.
2 RadiusNeighborsClassifier

O Raio no nome deste classificador representa os vizinhos mais próximos dentro de um raio especificado r, onde r é um valor de ponto flutuante especificado pelo usuário. Portanto, como o nome sugere, esse classificador implementa o aprendizado com base no número de vizinhos dentro de um raio fixo r de cada ponto de treinamento.

Regressor vizinho mais próximo

É usado nos casos em que os rótulos de dados são de natureza contínua. Os rótulos de dados atribuídos são calculados com base na média dos rótulos de seus vizinhos mais próximos.

A seguir estão os dois tipos diferentes de regressores do vizinho mais próximo usados ​​pelo scikit-learn -

KNeighboursRegressor

O K no nome deste regressor representa os k vizinhos mais próximos, onde k é um integer valueespecificado pelo usuário. Portanto, como o nome sugere, esse regressor implementa o aprendizado com base nos k vizinhos mais próximos. A escolha do valor de k depende dos dados. Vamos entender melhor com a ajuda de um exemplo de implementação.

A seguir estão os dois tipos diferentes de regressores do vizinho mais próximo usados ​​pelo scikit-learn -

Exemplo de Implementação

Neste exemplo, iremos implementar KNN no conjunto de dados denominado Conjunto de dados Iris Flower usando o scikit-learn KNeighborsRegressor.

Primeiro, importe o conjunto de dados da íris da seguinte forma -

from sklearn.datasets import load_iris
iris = load_iris()

Agora, precisamos dividir os dados em dados de treinamento e teste. Estaremos usando Sklearntrain_test_split função para dividir os dados na proporção de 70 (dados de treinamento) e 20 (dados de teste) -

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)

Em seguida, faremos o escalonamento de dados com a ajuda do módulo de pré-processamento Sklearn da seguinte maneira -

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

Em seguida, importe o KNeighborsRegressor classe de Sklearn e fornecer o valor de vizinhos como segue.

Exemplo

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

Resultado

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

Exemplo

Agora, podemos encontrar o MSE (erro quadrático médio) da seguinte forma -

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

Resultado

The MSE is: 4.4333349609375

Exemplo

Agora, use-o para prever o valor da seguinte maneira -

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

Resultado

[0.66666667]

Programa completo de trabalho / executável

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

RadiusNeighborsRegressor

O raio no nome deste regressor representa os vizinhos mais próximos dentro de um raio especificado r, onde r é um valor de ponto flutuante especificado pelo usuário. Conseqüentemente, como o nome sugere, este regressor implementa o aprendizado com base no número de vizinhos dentro de um raio fixo r de cada ponto de treinamento. Vamos entender melhor com a ajuda de um exemplo de implementação -

Exemplo de Implementação

Neste exemplo, iremos implementar KNN no conjunto de dados denominado Conjunto de dados Iris Flower usando o scikit-learn RadiusNeighborsRegressor -

Primeiro, importe o conjunto de dados da íris da seguinte forma -

from sklearn.datasets import load_iris
iris = load_iris()

Agora, precisamos dividir os dados em dados de treinamento e teste. Estaremos usando a função sklearn train_test_split para dividir os dados na proporção de 70 (dados de treinamento) e 20 (dados de teste) -

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)

Em seguida, faremos o escalonamento de dados com a ajuda do módulo de pré-processamento Sklearn da seguinte maneira -

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

Em seguida, importe o RadiusneighborsRegressor classe do Sklearn e forneça o valor de radius da seguinte forma -

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

Exemplo

Agora, podemos encontrar o MSE (erro quadrático médio) da seguinte forma -

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

Resultado

The MSE is: The MSE is: 5.666666666666667

Exemplo

Agora, use-o para prever o valor da seguinte maneira -

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

Resultado

[1.]

Programa completo de trabalho / executável

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