TechCodeview

• K-Nearest Neighbour é um dos algoritmos de aprendizado de máquina mais simples baseado na técnica de aprendizado supervisionado.
• O algoritmo K-NN assume a semelhança entre o novo caso/dados e os casos disponíveis e coloca o novo caso na categoria que é mais semelhante às categorias disponíveis.
• O algoritmo K-NN armazena todos os dados disponíveis e classifica um novo ponto de dados com base na similaridade. Isso significa que quando novos dados aparecem, eles podem ser facilmente classificados em uma categoria de conjunto de poços usando o algoritmo K-NN.
• O algoritmo K-NN pode ser usado para regressão e também para classificação, mas é usado principalmente para problemas de classificação.
• K-NN é um algoritmo não paramétrico , o que significa que não faz nenhuma suposição sobre os dados subjacentes.
• Também é chamado de algoritmo de aluno preguiçoso porque não aprende com o conjunto de treinamento imediatamente, em vez disso, armazena o conjunto de dados e, no momento da classificação, executa uma ação no conjunto de dados.
• O algoritmo KNN na fase de treinamento apenas armazena o conjunto de dados e, quando obtém novos dados, classifica esses dados em uma categoria que é muito semelhante aos novos dados.
Exemplo:Suponha que temos a imagem de uma criatura que se parece com um gato e um cachorro, mas queremos saber se é um gato ou um cachorro. Então para essa identificação podemos utilizar o algoritmo KNN, pois ele trabalha em uma medida de similaridade. Nosso modelo KNN encontrará as características semelhantes do novo conjunto de dados às imagens de cães e gatos e, com base nas características mais semelhantes, irá colocá-lo na categoria de gato ou cachorro.

Por que precisamos de um algoritmo K-NN?

Suponha que haja duas categorias, ou seja, Categoria A e Categoria B, e tenhamos um novo ponto de dados x1, então esse ponto de dados estará em qual dessas categorias. Para resolver este tipo de problema, precisamos de um algoritmo K-NN. Com a ajuda do K-NN, podemos identificar facilmente a categoria ou classe de um determinado conjunto de dados. Considere o diagrama abaixo:

Como funciona o KNN?

O funcionamento do K-NN pode ser explicado com base no algoritmo abaixo:

Passo 1:Selecione o número K dos vizinhosPasso 2:Calcule a distância euclidiana de K número de vizinhos Etapa 3:Pegue os K vizinhos mais próximos de acordo com a distância euclidiana calculada.Passo 4:Entre esses k vizinhos, conte o número de pontos de dados em cada categoria.Etapa 5:Atribua os novos pontos de dados à categoria para a qual o número do vizinho é máximo.Etapa 6:Nosso modelo está pronto.

Suponha que temos um novo ponto de dados e precisamos colocá-lo na categoria necessária. Considere a imagem abaixo:

serviços web java

• Primeiramente escolheremos o número de vizinhos, então escolheremos k=5.
• A seguir, calcularemos o Distância euclidiana entre os pontos de dados. A distância euclidiana é a distância entre dois pontos, que já estudamos em geometria. Pode ser calculado como:

• Calculando a distância euclidiana obtivemos os vizinhos mais próximos, como três vizinhos mais próximos na categoria A e dois vizinhos mais próximos na categoria B. Considere a imagem abaixo:

• Como podemos ver, os 3 vizinhos mais próximos são da categoria A, portanto este novo ponto de dados deve pertencer à categoria A.

Como selecionar o valor de K no algoritmo K-NN?

Abaixo estão alguns pontos a serem lembrados ao selecionar o valor de K no algoritmo K-NN:

• Não existe uma maneira específica de determinar o melhor valor para 'K', então precisamos tentar alguns valores para encontrar o melhor deles. O valor mais preferido para K é 5.
• Um valor muito baixo para K, como K=1 ou K=2, pode ser ruidoso e levar a efeitos de valores discrepantes no modelo.
• Valores grandes para K são bons, mas podem encontrar algumas dificuldades.

Vantagens do algoritmo KNN:

• É simples de implementar.
• É robusto para dados de treinamento barulhentos
• Pode ser mais eficaz se os dados de treinamento forem grandes.

Desvantagens do algoritmo KNN:

• Sempre é necessário determinar o valor de K, que pode ser complexo em algum momento.
• O custo de cálculo é alto devido ao cálculo da distância entre os pontos de dados para todas as amostras de treinamento.

Implementação Python do algoritmo KNN

Para fazer a implementação em Python do algoritmo K-NN, usaremos o mesmo problema e conjunto de dados que usamos na Regressão Logística. Mas aqui vamos melhorar o desempenho do modelo. Abaixo está a descrição do problema:

Problema para algoritmo K-NN: Há uma empresa fabricante de automóveis que fabricou um novo carro SUV. A empresa quer divulgar os anúncios aos usuários que tenham interesse em comprar aquele SUV. Portanto, para este problema, temos um conjunto de dados que contém informações de vários usuários através da rede social. O conjunto de dados contém muitas informações, mas o Salário estimado e Idade consideraremos para a variável independente e o Variável comprada é para a variável dependente. Abaixo está o conjunto de dados:

Etapas para implementar o algoritmo K-NN:

• Etapa de pré-processamento de dados
• Ajustando o algoritmo K-NN ao conjunto de treinamento
• Prevendo o resultado do teste
• Teste a precisão do resultado (matriz de criação de confusão)
• Visualizando o resultado do conjunto de testes.

Etapa de pré-processamento de dados:

A etapa de Pré-processamento de Dados permanecerá exatamente igual à Regressão Logística. Abaixo está o código para isso:

 # importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test) 

Ao executar o código acima, nosso conjunto de dados é importado para nosso programa e bem pré-processado. Após o dimensionamento do recurso, nosso conjunto de dados de teste ficará assim:

Na imagem de saída acima, podemos ver que nossos dados foram dimensionados com sucesso.

Ajustando o classificador K-NN aos dados de treinamento:
Agora ajustaremos o classificador K-NN aos dados de treinamento. Para fazer isso, importaremos o KNeighboursClassificador classe de Vizinhos Sklearn biblioteca. Após importar a classe, criaremos o Classificador objeto da classe. O parâmetro desta classe será
n_vizinhos:Para definir os vizinhos necessários do algoritmo. Normalmente, leva 5.métrica='minkowski':Este é o parâmetro padrão e decide a distância entre os pontos.p = 2:É equivalente à métrica euclidiana padrão.
E então ajustaremos o classificador aos dados de treinamento. Abaixo está o código para isso:

 #Fitting K-NN classifier to the training set from sklearn.neighbors import KNeighborsClassifier classifier= KNeighborsClassifier(n_neighbors=5, metric='minkowski', p=2 ) classifier.fit(x_train, y_train) 

Saída: Ao executar o código acima, obteremos a saída como:

 Out[10]: KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=5, p=2, weights='uniform') 

Prevendo o resultado do teste:Para prever o resultado do conjunto de testes, criaremos um y_pred vetor como fizemos na regressão logística. Abaixo está o código para isso:

 #Predicting the test set result y_pred= classifier.predict(x_test) 

Saída:

A saída para o código acima será:

Criando a Matriz de Confusão:
Agora criaremos a Matriz de Confusão para nosso modelo K-NN para ver a precisão do classificador. Abaixo está o código para isso:

 #Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred) 

No código acima, importamos a função confusão_matrix e a chamamos usando a variável cm.

Saída: Ao executar o código acima, obteremos a matriz conforme abaixo:

Na imagem acima, podemos ver que existem 64+29= 93 previsões corretas e 3+4= 7 previsões incorretas, enquanto, na Regressão Logística, houve 11 previsões incorretas. Portanto, podemos dizer que o desempenho do modelo é melhorado com o uso do algoritmo K-NN.

Visualizando o resultado do conjunto de treinamento:
Agora visualizaremos o resultado do conjunto de treinamento para o modelo K-NN. O código permanecerá o mesmo que fizemos na Regressão Logística, exceto o nome do gráfico. Abaixo está o código para isso:

 #Visulaizing the trianing set result from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

Ao executar o código acima, obteremos o gráfico abaixo:

c++ converte int em string

O gráfico de saída é diferente do gráfico que ocorreu na Regressão Logística. Isso pode ser entendido nos pontos abaixo:

• Como podemos ver, o gráfico mostra o ponto vermelho e os pontos verdes. Os pontos verdes são para a variável Comprada(1) e os Pontos Vermelhos para a variável Não Comprada(0).
• O gráfico mostra um limite irregular em vez de mostrar qualquer linha reta ou curva porque é um algoritmo K-NN, ou seja, encontrar o vizinho mais próximo.
• O gráfico classificou os usuários nas categorias corretas, pois a maioria dos usuários que não compraram o SUV estão na região vermelha e os usuários que compraram o SUV estão na região verde.
• O gráfico mostra um bom resultado, mas ainda assim existem alguns pontos verdes na região vermelha e pontos vermelhos na região verde. Mas isso não é um grande problema, pois ao fazer esse modelo evitam-se problemas de overfitting.
• Portanto, nosso modelo está bem treinado.
Visualizando o resultado do conjunto de testes:
Após o treinamento do modelo, iremos agora testar o resultado colocando um novo conjunto de dados, ou seja, conjunto de dados de teste. O código permanece o mesmo, exceto algumas pequenas alterações: como x_train e y_train será substituído por x_teste e y_teste .
Abaixo está o código para isso:

 #Visualizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('red','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('red', 'green'))(i), label = j) mtp.title('K-NN algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show() 

Saída:

O gráfico acima mostra a saída do conjunto de dados de teste. Como podemos ver no gráfico, o resultado previsto é bom, pois a maioria dos pontos vermelhos está na região vermelha e a maioria dos pontos verdes está na região verde.

No entanto, existem poucos pontos verdes na região vermelha e alguns pontos vermelhos na região verde. Portanto, essas são as observações incorretas que observamos na matriz de confusão (7 Saída incorreta).