- K-Nearest Neighbor es uno de los algoritmos de aprendizaje automático más simples basado en la técnica de aprendizaje supervisado.
- El algoritmo K-NN asume la similitud entre el nuevo caso/datos y los casos disponibles y coloca el nuevo caso en la categoría que es más similar a las categorías disponibles.
- El algoritmo K-NN almacena todos los datos disponibles y clasifica un nuevo punto de datos según la similitud. Esto significa que cuando aparecen nuevos datos, se pueden clasificar fácilmente en una categoría de conjunto de pozos utilizando el algoritmo K-NN.
- El algoritmo K-NN se puede utilizar tanto para regresión como para clasificación, pero principalmente se utiliza para problemas de clasificación.
- K-NN es un algoritmo no paramétrico , lo que significa que no hace ninguna suposición sobre los datos subyacentes.
- También se le llama un algoritmo de aprendizaje perezoso porque no aprende del conjunto de entrenamiento inmediatamente, sino que almacena el conjunto de datos y, en el momento de la clasificación, realiza una acción en el conjunto de datos.
- El algoritmo KNN en la fase de entrenamiento simplemente almacena el conjunto de datos y cuando obtiene nuevos datos, los clasifica en una categoría que es muy similar a los nuevos datos.
¿Por qué necesitamos un algoritmo K-NN?
Supongamos que hay dos categorías, es decir, Categoría A y Categoría B, y tenemos un nuevo punto de datos x1, por lo que este punto de datos estará en cuál de estas categorías. Para resolver este tipo de problemas, necesitamos un algoritmo K-NN. Con la ayuda de K-NN, podemos identificar fácilmente la categoría o clase de un conjunto de datos en particular. Considere el siguiente diagrama:
¿Cómo funciona K-NN?
El funcionamiento de K-NN se puede explicar sobre la base del siguiente algoritmo:
Supongamos que tenemos un nuevo punto de datos y necesitamos colocarlo en la categoría requerida. Considere la siguiente imagen:
convertir de char a int java
- En primer lugar, elegiremos el número de vecinos, por lo que elegiremos k=5.
- A continuación calcularemos la distancia euclidiana entre los puntos de datos. La distancia euclidiana es la distancia entre dos puntos, que ya hemos estudiado en geometría. Se puede calcular como:
- Al calcular la distancia euclidiana obtuvimos los vecinos más cercanos, como tres vecinos más cercanos en la categoría A y dos vecinos más cercanos en la categoría B. Considere la siguiente imagen:
- Como podemos ver, los 3 vecinos más cercanos son de la categoría A, por lo tanto, este nuevo punto de datos debe pertenecer a la categoría A.
¿Cómo seleccionar el valor de K en el algoritmo K-NN?
A continuación se presentan algunos puntos para recordar al seleccionar el valor de K en el algoritmo K-NN:
- No existe una forma particular de determinar el mejor valor para 'K', por lo que debemos probar algunos valores para encontrar el mejor valor. El valor más preferido para K es 5.
- Un valor muy bajo de K, como K=1 o K=2, puede generar ruido y provocar efectos de valores atípicos en el modelo.
- Los valores grandes para K son buenos, pero pueden encontrar algunas dificultades.
Ventajas del algoritmo KNN:
- Es sencillo de implementar.
- Es robusto a los ruidosos datos de entrenamiento.
- Puede ser más eficaz si los datos de entrenamiento son grandes.
Desventajas del algoritmo KNN:
- Siempre es necesario determinar el valor de K, lo cual puede resultar complejo en algún momento.
- El costo de cálculo es alto debido al cálculo de la distancia entre los puntos de datos para todas las muestras de entrenamiento.
Implementación en Python del algoritmo KNN
Para realizar la implementación en Python del algoritmo K-NN, usaremos el mismo problema y conjunto de datos que usamos en Regresión logística. Pero aquí mejoraremos el rendimiento del modelo. A continuación se muestra la descripción del problema:
Problema para el algoritmo K-NN: Hay una empresa fabricante de automóviles que ha fabricado un nuevo vehículo SUV. La empresa quiere entregar los anuncios a los usuarios que estén interesados en comprar ese SUV. Entonces, para este problema, tenemos un conjunto de datos que contiene información de múltiples usuarios a través de la red social. El conjunto de datos contiene mucha información, pero el Salario estimado y Edad consideraremos para la variable independiente y la variable comprada es para la variable dependiente. A continuación se muestra el conjunto de datos:
Pasos para implementar el algoritmo K-NN:
- Paso de preprocesamiento de datos
- Ajustar el algoritmo K-NN al conjunto de entrenamiento
- Predecir el resultado de la prueba
- Pruebe la precisión del resultado (Creación de matriz de confusión)
- Visualizando el resultado del conjunto de pruebas.
Paso de preprocesamiento de datos:
El paso de preprocesamiento de datos seguirá siendo exactamente el mismo que el de la regresión logística. A continuación se muestra el código para ello:
# 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)
Al ejecutar el código anterior, nuestro conjunto de datos se importa a nuestro programa y se procesa previamente. Después de escalar las funciones, nuestro conjunto de datos de prueba se verá así:
En la imagen de salida de arriba, podemos ver que nuestros datos se escalaron correctamente.
Ahora ajustaremos el clasificador K-NN a los datos de entrenamiento. Para ello importaremos el Clasificador KVecinos clase de Vecinos de Sklearn biblioteca. Después de importar la clase, crearemos la Clasificador objeto de la clase. El parámetro de esta clase será
#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)
Salida: Al ejecutar el código anterior, obtendremos el resultado como:
Out[10]: KNeighborsClassifier(algorithm='auto', leaf_size=30, metric='minkowski', metric_params=None, n_jobs=None, n_neighbors=5, p=2, weights='uniform')
#Predicting the test set result y_pred= classifier.predict(x_test)
Producción:
La salida del código anterior será:
Ahora crearemos la Matriz de confusión para nuestro modelo K-NN para ver la precisión del clasificador. A continuación se muestra el código para ello:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
En el código anterior, importamos la función confusion_matrix y la llamamos usando la variable cm.
Producción: Al ejecutar el código anterior, obtendremos la matriz como se muestra a continuación:
alinear imagen css
En la imagen de arriba, podemos ver que hay 64+29= 93 predicciones correctas y 3+4= 7 predicciones incorrectas, mientras que, en Regresión Logística, hubo 11 predicciones incorrectas. Entonces podemos decir que el rendimiento del modelo mejora al utilizar el algoritmo K-NN.
Ahora, visualizaremos el resultado del conjunto de entrenamiento para el modelo K-NN. El código seguirá siendo el mismo que hicimos en Regresión logística, excepto el nombre del gráfico. A continuación se muestra el código para ello:
#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()
Producción:
Al ejecutar el código anterior, obtendremos el siguiente gráfico:
El gráfico de salida es diferente del gráfico que obtuvimos en Regresión logística. Se puede entender en los siguientes puntos:
- Como podemos ver, el gráfico muestra el punto rojo y los puntos verdes. Los puntos verdes son para la variable Comprado(1) y los puntos rojos para la variable No Comprado(0).
- El gráfico muestra un límite irregular en lugar de mostrar una línea recta o una curva porque es un algoritmo K-NN, es decir, encontrar el vecino más cercano.
- El gráfico ha clasificado a los usuarios en las categorías correctas, ya que la mayoría de los usuarios que no compraron el SUV están en la región roja y los usuarios que compraron el SUV están en la región verde.
- El gráfico muestra un buen resultado, pero aún así hay algunos puntos verdes en la región roja y puntos rojos en la región verde. Pero esto no es un gran problema ya que al hacer este modelo se evitan problemas de sobreajuste.
- Por tanto, nuestro modelo está bien entrenado.
Después de entrenar el modelo, ahora probaremos el resultado colocando un nuevo conjunto de datos, es decir, conjunto de datos de prueba. El código sigue siendo el mismo excepto algunos cambios menores: como tren_x y tren_y será reemplazado por prueba_x y prueba_y .
A continuación se muestra el código para ello:
#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()
Producción:
El gráfico anterior muestra el resultado del conjunto de datos de prueba. Como podemos ver en el gráfico, el resultado previsto es muy bueno ya que la mayoría de los puntos rojos están en la región roja y la mayoría de los puntos verdes están en la región verde.
Sin embargo, hay pocos puntos verdes en la región roja y algunos puntos rojos en la región verde. Entonces estas son las observaciones incorrectas que hemos observado en la matriz de confusión (7 Salida incorrecta).