En esta entrada explicaremos la parte práctica del algoritmo de Bosques Aleatorio Clasificación, en donde desarrollaremos un modelo para predecir si un paciente tiene cáncer de seno o no.
A su vez, te recomiendo que, si no haz visto la información anterior referente a la teoría y cómo implementar este algoritmo utilizando la librería Scikit Learn te vayas a verlos porque son las bases para entender lo que se explicará en este.
Para este proyecto vamos a continuar utilizando el conjunto de datos del cáncer de seno o BreastCancer que se encuentra disponible dentro de la librería scikit learn.
Este es el mismo conjunto de datos que utilizamos para la parte práctica del algoritmo de Regresión Logística acá importamos los datos y realizamos el respectivo preprocesamiento de los datos, por tal razón acá solamente nos enfocaremos en cómo implementar el algoritmo de Bosques Aleatorios Clasificación. Te recomiendo que veas la información publicada en ese contenido en caso de que quieras conocer más como hacer la primera parte de este proyecto.
En este punto ya hemos separados los datos de “X”, correspondiente a data y los datos de “y” correspondiente a target. Para construir el modelo debemos separar nuevamente los datos, pero esta vez en datos de entrenamiento y en datos de prueba, para esto utilizamos la instrucción train_test_split la cual nos ahorra bastante el trabajo.
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 debemos hacer es importar el modulo de Scikit Learn para trabajar con el algoritmo de Bosques Aleatorios Clasificación, para ello escribimos en nuestro programa from sklearn punto ensemble import RandomForestClassifier.
#Bosques Aleatorios from sklearn.ensemble import RandomForestClassifier algoritmo = RandomForestClassifier(n_estimators = 10, criterion = 'entropy')
Con esta simple línea de código ya podemos empezar a utilizar este algoritmo por lo que lo definimos en nuestro programa en donde algoritmos será igual a RadomForestClassifier, y acá empezamos a definir los parámetros respectivos de este algoritmo.
El primero de ellos es n_estimators que será el estimado de árboles, en este caso vamos a colocar 10, este número lo podrás variar por tu cuenta para que puedas verificar el comportamiento del algoritmo, si mejora o no los resultados obtenidos.
El siguiente parámetro que vamos a definir es criterion, que se refiere a la medida de selección. Por defecto este parámetro viene configurado con el índice Gini pero para nuestro ejercicio lo vamos a cambiar por “entropy” o entropía en español. Para entender mejor esto te recomiendo que buques la información publicada sobre la librería scikit learn para este algoritmo.
El resto de parámetros los dejaremos con sus valores por defecto, en caso de que quieras definirlos por tu cuenta lo puedes hacer sin ningún problema.
Realizado todo esto ya podemos entrenar el modelo utilizando el algoritmo con los parámetros definidos y con los datos de entrenamiento definidos anteriormente.
#Entreno el modelo algoritmo.fit(X_train, y_train)
Seguidamente utilizamos la instrucción predict() para realizar la predicción utilizando los datos de prueba, acá lo que queremos hacer es probar que tan bien funciona el modelo que hemos desarrollado.
#Realizo una predicción y_pred = algoritmo.predict(X_test)
Verifiquemos ahora que tan bueno es el modelo desarrollado, para esto 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 108 datos correctos y tan solo 6 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 calculo es de 0,958, 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.
A continuación encontrarás ell código completo:
"""
Bosques Aleatorios Clasificación
"""
########## 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 BOSQUES ALEATORIOS CLASIFICACIÓN ##########
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
#Bosques Aleatorios
from sklearn.ensemble import RandomForestClassifier
algoritmo = RandomForestClassifier(n_estimators = 10, criterion = 'entropy')
#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)
La Verdad Eres una Tesa, Muchas gracias por compartirnos tu conocimiento 😀
Muchas gracias Edison. Saludos.