Naive Bayes – Práctica con Python
A continuación aprenderás cómo implementar el algoritmo Naive Bayes 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 Naive Bayes. 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.
Naive Bayes 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 Naive Bayes.
Para implementar este algoritmo lo primero que se debe definir es el módulo, sklearn.naive_bayes, e importamos la clase que será GaussianNB. Este módulo cuenta con distintas clases, pero la mencionada acá es la más utilizada de todas.
Una vez que se haya realizado esto se puede implementar este algoritmo en el programa que se este desarrollando. Para realizar el entrenamiento del modelo se utiliza la instrucción fit() junto al algoritmo y para realizar una predicción se utilizar predict() junto al algoritmo. Para aplicar ambas instrucciones se deberá haber definido previamente las variables independientes y dependiente para poderlas utilizar acá. Este es el mismo procedimiento que se ha utilizado con los otros algoritmos de Machine Learning que se han explicado.
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 Naive Bayes con Scikit Learn
Este algoritmo por ser muy básico no requiere de mucha configuración de parámetros, inclusive solamente cuenta con tan solo dos parámetros, que por lo general no se utilizan. En otras palabras, al implementar este algoritmo se deja tal cual como está sin realizar ninguna configuración de los parámetros.
Resumen de comandos Scikit Learn
Si hacemos un resumen de los comandos para implementar el algoritmo de Naive Bayes son los siguientes:
Sabiendo cómo implementar el algoritmo de Naive Bayes 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
Seguidamente definimos el algoritmo, en este caso le indicamos a nuestro programa, de sklearn.naive_bayes vamos a importar GaussianNB, con esto ya podemos implementar este algoritmo dentro de nuestro programa.
#Naive Bayes
from sklearn.naive_bayes import GaussianNB
algoritmo = GaussianNB()
Por tal motivo entrenamos el modelo junto a los datos de entrenamiento.
#Entreno el modelo
algoritmo.fit(X_train, y_train)
Seguidamente realizamos una predicción junto a los datos de pruebas que separamos previamente.
#Realizo una predicción
y_pred = algoritmo.predict(X_test)
Análisis de los resultados
Verifiquemos como es el modelo utilizando las métricas de los problemas de clasificación, para ello vamos a comenzar obteniendo la matriz de confusión. Para esto importamos del módulo scikitlearn.metrics, confusion_matrix, y aplicamos esta instrucción junto a los datos de prueba y los obtenidos en la predicción realizada previamente.
#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)
El resultado acá, es que tenemos 113 datos predichos correctamente y 1 dato erróneo obtenido luego de realizar la predicción.
Viendo este resultado podemos concluir que el modelo predijo la gran mayoría de los datos por lo que es un buen modelo que podemos utilizar.
Ahora veamos la precisión del mismo, para esto importamos precision_score del módulo sklearn.metrics y lo implementamos de igual forma junto a los datos de entrenamiento y los predichos.
#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 obtenido acá es de 0,986. Por lo que consideramos que el modelo cumple con su función.
Programa completo
A continuación se encuentra el código completo:
"""
Naive Bayes
"""
########## 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 NAIVE BAYES ##########
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
#Naive Bayes
from sklearn.naive_bayes import GaussianNB
algoritmo = GaussianNB()
#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.
