K Vecinos más Cercanos – Práctica con Python
A continuación aprenderás cómo implementar el algoritmo de K Vecinos más Cercanos utilizando la librería de Python Scikit Learn, tomando en cuenta cada uno de los parámetros que debes considerar para ajustar y mejorar tus resultados.
Posteriormente desarrollaremos un proyecto de Machine Learning enfocándonos en el algoritmo de K Vecinos más Cercanos. Cada una de las explicaciones dadas acá será paso a paso para que puedas entender con detalle cada uno de los métodos explicados acá y que los puedas implementar en tus propios proyectos.
Empecemos con la explicación del proyecto.
K Vecinos más Cercanos con Scikit Learn
Si aún no lo sabes, Scikit Learn es una de las más grandes librerías de Machine Learning con la que cuenta Python, pero no solamente eso, es de las más utilizadas al momento de crear los modelos implementando los algoritmos de Machine Learning, por estas razones es muy importante que aprendas a trabajar con ella si apenas te estás iniciando.
Veamos cómo se puede utilizar esta librería para implementar el algoritmo de K Vecinos más Cercanos.
La librería Scikit Learn cuenta con un modelo que se puede utilizar para implementar el algoritmo de K vecinos más cercanos clasificación. Para implementar este algoritmo lo primero que se debe realidad es definir el modulo, en este caso sería: skelearn.neigbors. Realizado esto se procede a importar la clase en este caso será KNeighborsClassifier. Recuerda que este algoritmo también se puede usar para problemas de regresión, pero la clase para este se define distinto al de clasificación.
Toda la información para implementar esta librería la pueden encontrar directamente en la página web, por lo que si tenemos alguna duda en la implementación de las instrucciones solamente tenemos que leer esta información.
Implementación de K Vecinos más Cercanos con Scikit Learn
La librería te ofrece varios parámetros que puedes utilizar para configurar el algoritmo y algunos de ellos son muy útiles para mejorar el modelo que se esté construyendo.
El primer parámetro, por su puesto debe ser el del número de vecinos o K, acá es donde defines este valor, a este parámetro se le conoce acá como n_neighbors. Por defecto es 5, pero es recomendable que en cada proyecto sea el desarrollador quien defina este valor para tener más control sobre el modelo.
Otro parámetro importante y que lo mencionamos cuando vimos la teoría de este algoritmo es definir la distancia que se utilizará para verificar los vecinos del dato que se está buscando predecir. Para configurar esto en el algoritmo se debe definir dos variables dentro del algoritmo, la primera es “p” y la segunda es “metric”.
“p” por defecto es igual a 2 y “metric” por defecto es “minkowski”, con esta combinación se está eligiendo la distancia euclidiana como la que se implementará.
En el caso de querer utilizar la distancia manhattan se deberá colocar “p” igual 1. Y en caso de que se quiera utilizar la distancia minkowski, se deberá colocar un valor arbitrario a “p”
Con estos parámetros puedes desarrollar un buen modelo utilizando el algoritmo de K vecinos más cercano clasificación. Este algoritmo cuenta con otros parámetros que pueden ser modificados pero a medida que ganes más experiencia en el desarrollo de proyectos de Machine Learning podrás implementarlos en tus proyectos.
Puedes ver los otros parámetros en la página oficial de la librería.
Ahora los comandos para entrenar el algoritmo y realizar una predicción son los mismos que con el resto de algoritmos de Machine Learning, fit() y predict (), respectivamente. Para implementar estas instrucciones deberás definir los parámetros de “x” y “y”.
Ahora bien, después de realizar todo este procedimiento solamente falta evaluar el rendimiento del modelo construido, este paso es particularmente importante para comparar qué tan bien funcionan diferentes algoritmos en un conjunto de datos particular. Se puede utilizar la instrucción “score” junto con los datos de pruebas, pero aconsejo mejor utilizar todos los datos de métricas que se explicaron anteriormente para obtener una mejor información del modelo.
Resumen de comandos Scikit Learn
En resumen, los comandos a utilizar para implementar un algoritmo de K vecinos más cercanos clasificación serían los siguientes:
Sabiendo cómo implementar el algoritmo de K Vecinos más. Cercanos con la librería de Scikit Learn, ha llegado el momento de desarrollar un proyecto práctico.
Definición del proyecto
En esta práctica del algoritmo de Naive Bayes, se desarrollará un modelo para predecir el cancer de seno.
Para este análisis vamos a utilizar el dataset disponible en la librería scikit-learn correspondiente al Breast Cancer o cáncer de seno. Si no lo sabías dentro de la librería sckit-learn se dispone de varios conjuntos de datos, muy básicos, con los que puedes practicar tus conocimientos de Machine Learning, no son muchos, pero cubre los principales tipos de algoritmos como regresión y clasificación.
El algoritmo específico que se utilizará será Naive Bayes.
Obtener los de datos
El primer paso que daremos será el de importar las librerías que vamos utilizar, en especial las necesarias para importar los datos que utilizaremos.
En este caso vamos a importar de sklearn el datasets, que es donde se guardan todos los conjuntos de datos que dispone esta librería.
#Se importan la librerias a utilizar
from sklearn import datasets
Ahora procedemos a importar los datos, para ello utilizamos la instrucción datasets punto load breast cancer y almacenamos esta información dentro de la variable dataset.
#Importamos los datos de la misma librería de scikit-learn
dataset = datasets.load_breast_cancer()
print(dataset)
Tenemos mucha información dentro de esta variable lo que se nos hace difícil entender la información, por lo tanto, ahora procedemos a entender la data.
Entender los datos
Para entender los datos que estaremos utilizando el proyecto nos vamos a valer de varias instrucciones propias de Python y así verificar la información contenida en el conjunto de datos que acabamos de importar. Para este fin utilizamos la instrucción keys.
print('Información en el dataset:')
print(dataset.keys())
Como podemos observar nos indica que el dataset cuenta con la siguiente información: primeramente “data”, que serían los datos independientes, seguidamente “target”, correspondiente a la columna con las etiquetas o respuestas, posteriormente tenemos “target_names” que son los nombres de las variables que se encuentran en la columna de “target”, después tenemos “DESCR” que sería la descripción total del dataset y finalmente tenemos “features_names” correspondiente a los nombres de cada una de las columnas de los datos.
Ya sabiendo todo esto podemos utilizar cada uno de estos nombres para entender mejor los datos, lo primero que vamos hacer es utilizar “DESCR” para conocer las características del dataset.
#Verificamos las características del dataset
print('Características del dataset:')
print(dataset.DESCR)
Aplicado el respectivo comando, podemos verificar que el dataset cuenta con 569 datos y un total de 30 atributos, todos ellos numéricos.
Algunos de los atributos o variables independientes son: el radio, la textura, el perímetro y el área, recuerda que acá vamos a predecir si un paciente tiene cáncer o no, para ello debemos conocer todas las características del tumor para determinar con ella si el tumor es maligno o benigno.
Podemos observar que de cada una de estas variables tenemos la información de la media, el error estándar y el peor, que vendría siendo la media de los tres valores más grandes.
Toda esta información hace los 30 atributos que en total cuenta este dataset.
Otro dato importante que nos proporciona esta información es que no existe ningún atributo perdido por lo que el dataset está completo haciendo que no sea necesario el preprocesamiento de los datos, para completar con datos perdidos.
Finalmente nos indica que en estos datos 212 son tumores malignos mientras que 357 son benignos, esto nos indica que los datos se encuentran balanceados por lo que no nos tenemos que preocupar por trabajar con un dataset desbalanceado.
Con esta información considero que ya tenemos más claro el dataset con el que estamos trabajando. En caso de que quieras profundizar en alguna información adicional puedes utilizar cualquiera de las otras instrucciones que he explicado en anteriores videos.
Ahora vamos a proceder a definir las variables de “X” y “y” que vamos emplear en nuestro modelo.
Procesamiento de los datos
Para “X” vamos a utilizar todas las variables que se encuentran dentro de “data”, por lo que la igualamos a dataset punto data.
#Seleccionamos todas las columnas
X = dataset.data
Por su parte, “y” será igual a los datos correspondientes a “target” por lo que igualamos esta variable a dataset punto target.
#Defino los datos correspondientes a las etiquetas
y = dataset.target
Recuerda que “y” cuenta con una sola columna con solamente ceros y unos, los unos indican que el tumor es maligno mientras que los ceros corresponden al tumor benigno.
Definido “X” y “y” ya podemos realizar la separación correspondiente a los datos de prueba y entrenamiento para ello importamos la respectiva librería y procedemos a utilizar train_test_split para separar los datos.
Para la separación de los datos, vamos a tomar un 20% de los mismos para utilizarlos como prueba una vez que hayamos obtenido el modelo.
from sklearn.model_selection import train_test_split
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
El siguiente paso que realizaremos es escalar los datos, esto se hace ya que las características son completamente distintas en magnitudes, unidades y rango por lo que lo mejor es escalarlos para llevarlos a un mismo nivel de magnitudes.
Para realizar este procedimiento importaremos el método StandarScaler de la librería scikit-learn.
#Se escalan todos los datos
from sklearn.preprocessing import StandardScaler
Seguidamente igualamos la variable escalar a “StandardScaler” para que lo podamos implementar con nuestros datos.
Para realizar este procedimiento importamos el método StandardScaler de la librería scikit-learn.
escalar = StandardScaler()
Realizado todo ahora si podemos escalar los datos, para nuestro caso los datos a escalar son lo que tenemos dentro de las variables “X” tanto de entrenamiento como de prueba.
Ahora para realizar el escalamiento utilizaremos fit_transform, esta instrucción realiza el calculo respectivo y a su vez transforma y devuelve los datos ya escalados.
X_train = escalar.fit_transform(X_train)
X_test = escalar.transform(X_test)
Ya en este momento tenemos nuestros datos listos para empezar a construir el modelo.
Desarrollo del algoritmo
Con esto ya estamos listo para empezar a desarrollar nuestro modelo. Por tal motivo importamos el algoritmo que se encuentra dentro de “skelarn.neighbors”, importamos KNeighborsClassifier.
#Defino el algoritmo a utilizar
from sklearn.neighbors import KNeighborsClassifier
algoritmo = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
Realizado esto definamos nuestro algoritmo y lo configuramos acá le indicamos que “k” o el número de vecinos será igual a 5, la métrica será “minkowski” y “p” será igual a 2. Recuerda que la combinación de estos dos elementos le indica al algoritmo que utilizará la distancia Euclidiana para verificar la distancia entre los vecinos, esto fue explicado anteriormente.
Si te fijas estos son los datos predeterminado con los que viene configurado el algoritmo si lo deseas puedes eliminar esta configuración y dejar el paréntesis vacío, pero lo hago así para que posteriormente tú puedas realizar cambios y ajustes para mejorar el modelo.
Definido el algoritmo ahora entrenamos el modelo utilizando los datos de entrenamiento.
#Entreno el modelo
algoritmo.fit(X_train, y_train)
Y realizamos una predicción utilizando los datos de prueba.
#Realizo una predicción
y_pred = algoritmo.predict(X_test)
Análisis de los resultados
Si comparamos los datos calculados con los datos reales podemos observar que la gran mayoría coincide mientras que algunos no, pero en su mayoría si coinciden, por lo que a simple vista se puede determinar que el modelo desarrolla es bueno.
Pero veamos si esto es cierto, para calculemos la matriz de confusión, para esto importamos de metrics de sklean el método confusion_matrix y lo implementamos junto con los datos predichos y los datos reales.
#Verifico la matriz de Confusión
from sklearn.metrics import confusion_matrix
matriz = confusion_matrix(y_test, y_pred)
print('Matriz de Confusión:')
print(matriz)
Como podemos observar fueron muy pocos los datos que no fueron predichos correctamente, recuerda que los datos ubicados en la diagonal principal son los datos predichos correctamente mientras que en la diagonal secundaria son los errores. Por lo que si sumamos estos elementos obtuvimos 109 datos correctos y tan solo 5 datos incorrectos.
Veamos ahora la precisión del modelo, para ello importamos “precision_score” de metrics y la implementamos junto con los datos predichos y los reales.
#Calculo la precisión del modelo
from sklearn.metrics import precision_score
precision = precision_score(y_test, y_pred)
print('Precisión del modelo:')
print(precision)
El resultado de este cálculo es de 0,974, este es un valor bastante aceptable.
Con esto podemos concluir que con este algoritmo podemos obtener muy buenos resultados con este conjunto de datos. Ya queda de tu parte si deseas mejorarlo y ver si es posible obtener algo más preciso, para ello puedes modificar los datos de la configuración del algoritmo.
Programa completo
A continuación se encuentra el código completo:
"""
K Vecinos más Cercanos
"""
########## LIBRERÍAS A UTILIZAR ##########
#Se importan la librerias a utilizar
from sklearn import datasets
########## PREPARAR LA DATA ##########
#Importamos los datos de la misma librería de scikit-learn
dataset = datasets.load_breast_cancer()
print(dataset)
########## ENTENDIMIENTO DE LA DATA ##########
#Verifico la información contenida en el dataset
print('Información en el dataset:')
print(dataset.keys())
print()
#Verifico las características del dataset
print('Características del dataset:')
print(dataset.DESCR)
#Seleccionamos todas las columnas
X = dataset.data
#Defino los datos correspondientes a las etiquetas
y = dataset.target
########## IMPLEMENTACIÓN DE K VECINOS MÁS CERCANOS ##########
from sklearn.model_selection import train_test_split
#Separo los datos de "train" en entrenamiento y prueba para probar los algoritmos
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)
#Defino el algoritmo a utilizar
from sklearn.neighbors import KNeighborsClassifier
algoritmo = KNeighborsClassifier(n_neighbors = 5, metric = 'minkowski', p = 2)
#Entreno el modelo
algoritmo.fit(X_train, y_train)
#Realizo una predicción
y_pred = algoritmo.predict(X_test)
#Verifico la matriz de Confusión
from sklearn.metrics import confusion_matrix
matriz = confusion_matrix(y_test, y_pred)
print('Matriz de Confusión:')
print(matriz)
#Calculo la precisión del modelo
from sklearn.metrics import precision_score
precision = precision_score(y_test, y_pred)
print('Precisión del modelo:')
print(precision)
Si te llamo la atención todo este contenido y te animaste a empezar a estudiar Inteligencia Artificial, he desarrollado un curso que te ayudará, de igual forma a iniciar tu camino dentro de está tecnología. Este curso te sentará las bases y te dará más claridad para poder seleccionar el enfoque o área que más te interese sobre la Inteligencia Artificial, de igual forma te ayudará tener más claridad en muchos conceptos que seguramente en estos momentos te parece confusos. Este curso es ideal si apenas estás empezando. Si quieres más información puedes ingresar a este enlace.
