Guía Definitiva del Algoritmo Random Forest con Python y Scikit-Learn

Introducción

El algoritmo Random Forest es uno de los algoritmos más flexibles, potentes y ampliamente utilizados para clasificación y regresión, construido como un conjunto de árboles de decisión.

Si no está familiarizado con estos, no se preocupe, cubriremos todos estos conceptos.

En esta guía práctica detallada, crearemos un intuición sobre cómo funcionan los árboles de decisión, cómo el conjunto impulsa los clasificadores y regresores individuales, qué son los bosques aleatorios y construir un clasificador y regresor de bosque aleatorio usando Python y Scikit-Learn, a través de un mini proyecto de extremo a extremo, y responder una pregunta de investigación.

Considere que actualmente forma parte de un grupo de investigación que está analizando datos sobre mujeres. El grupo ha recopilado 100 registros de datos y quiere poder organizar esos registros iniciales dividiendo a las mujeres en categorías: estar o no embarazadas y vivir en áreas rurales o urbanas. Los investigadores quieren saber cuántas mujeres habría en cada categoría.

Hay una estructura computacional que hace exactamente eso, es el árbol estructura. Al usar una estructura de árbol, podrá representar las diferentes divisiones para cada categoría.

Árboles de decisión

¿Cómo se pueblan los nodos de un árbol? Aquí es donde árboles de decisión entrar en foco.

Primero, podemos dividir los registros por embarazo, después de eso, podemos dividirlos por vivir en áreas urbanas o rurales. Tenga en cuenta que podríamos hacer esto en un orden diferente, dividiendo inicialmente por el área donde viven las mujeres y luego por su estado de embarazo. A partir de esto, podemos ver que el árbol tiene una jerarquía inherente. Además de organizar la información, un árbol organiza la información de manera jerárquica: el orden en que aparece la información es importante y, como resultado, conduce a diferentes árboles.

A continuación, se muestra un ejemplo del árbol que se ha descrito:

En la imagen del árbol, hay 7 cuadrados, el de arriba que representa el total de 100 mujeres, este cuadrado de arriba está conectado con dos cuadrados de abajo, que dividen a las mujeres según su número de 78 no embarazadas y 22 embarazadas, y de los dos cuadrados anteriores hay cuatro cuadrados; dos conectados a cada cuadro de arriba que dividen a las mujeres según su área, para las no embarazadas, 45 viven en zona urbana, 33 en zona rural y para las embarazadas, 14 viven en zona rural y 8 en zona urbana. Con solo mirar el árbol, es fácil entender esas divisiones y ver cómo cada "capa" se deriva de las anteriores, esas capas son el árbol. , los niveles describen la profundidad del árbol:

Observe en la imagen de arriba que el primer nivel del árbol es nivel 0 donde solo hay un cuadrado, seguido de nivel 1 donde hay dos cuadrados, y nivel 2 donde hay cuatro cuadrados. Esto es un profundidad 2 árbol.

En el nivel 0 se encuentra el cuadrado que da origen al árbol, el primero, llamado nodo raíz, esta raíz tiene dos nodos secundarios en el nivel 1, que son nodos padres a los cuatro nodos en el nivel 2. Fíjate que los “cuadrados” que hemos estado mencionando hasta ahora, en realidad se llaman nodos; y que cada nodo anterior es padre de los nodos siguientes, que son sus hijos. Los nodos hijos de cada nivel que tienen el mismo padre se denominan los hermanos, como se puede apreciar en la siguiente imagen:

En la imagen anterior, también mostramos el nivel 1 como el nodos interiores, una vez que están entre la raíz y los últimos nodos, que son los ganglios foliares. Los nudos de las hojas son la última parte de un árbol, si tuviéramos que decir de las 100 mujeres iniciales, cuántas están embarazadas y viven en zonas rurales, podríamos hacerlo mirando las hojas. Entonces, el número en las hojas respondería la primera pregunta de investigación.

Si hubiera nuevos registros de mujeres, y el árbol que antes se usaba para categorizarlas, ahora se usara para decidir si una mujer podía o no ser parte de la investigación, ¿seguiría funcionando? El árbol usaría los mismos criterios, y una mujer sería elegible para participar si está embarazada y vive en un área rural.

Al observar la imagen de arriba, podemos ver que las respuestas a las preguntas de cada nodo del árbol: "¿participa?", "¿está embarazada?", "¿vive en un área rural?" - son sí, sí, y sí, entonces parece que el árbol puede conducir a una decisión, en este caso, que la mujer podría participar en la investigación.

Este es el esencia de árboles de decisión en, hecho de manera manual. Usando Machine Learning, podemos construir un modelo que construya este árbol automáticamente para nosotros, de tal manera de maximizar la precisión de las decisiones finales.

En los ejemplos anteriores, observe cómo el árbol podría clasificar nuevos datos como participante o no participante, o también se podrían cambiar las preguntas a – “¿cuántas son participantes?”, “¿cuántas están embarazadas?”, “¿cuántas viven en una zona rural?”, lo que nos lleva a encontrar la la cantidad de participantes embarazadas que viven en una zona rural.

Cuando se clasifican los datos, esto significa que el árbol está realizando una clasificación tarea, y cuando se encuentra la cantidad de datos, el árbol está realizando una regresión tarea. Esto significa que el árbol de decisión se puede utilizar para ambas tareas: clasificación y regresión.

Ahora que entendemos qué es un árbol de decisión, cómo se puede usar y qué nomenclatura se usa para describirlo, podemos preguntarnos acerca de sus limitaciones.

Comprender los bosques aleatorios

¿Qué pasa con la decisión si algún participante vive en la división entre áreas urbanas y rurales? ¿Agregaría el árbol este registro a rural o urbano? Parece difícil encajar estos datos en la estructura que tenemos actualmente, ya que es bastante claro.

Además, ¿qué pasa si en la investigación participa una mujer que vive en un barco, se consideraría rural o urbano? Al igual que el caso anterior, es un dato difícil de clasificar teniendo en cuenta las opciones disponibles en el árbol.

Al pensar un poco más en el ejemplo del árbol de decisión, podemos ver que puede clasificar correctamente nuevos datos considerando que ya sigue un patrón que el árbol ya tiene, pero cuando hay registros que difieren de los datos iniciales que definieron el árbol, el la estructura del árbol es demasiado rígida, lo que hace que los registros no sean clasificables.

Esto significa que el árbol de decisiones puede ser estricto y limitado en sus posibilidades. Un árbol de decisiones ideal sería más flexible y capaz de acomodar datos invisibles más matizados.

En cuanto a la respuesta a la pregunta inicial, ya sabemos que estará codificada en las hojas de los árboles, pero ¿qué cambia cuando tenemos muchos árboles en lugar de uno?

Si los árboles se combinan para una clasificación, el resultado estará definido por la mayoría de las respuestas, esto se llama voto mayoritario; y en el caso de una regresión, el número dado por cada árbol en el bosque será promediado.

Aprendizaje en conjunto y conjuntos modelo

Este método se conoce como aprendizaje conjunto. Al emplear el aprendizaje conjunto, puede mezclar cualquier algoritmo, siempre que pueda asegurarse de que la salida se pueda analizar y combinar con otras salidas (ya sea manualmente o usando bibliotecas existentes). Por lo general, reúne varios modelos del mismo tipo, como árboles de decisión múltiples, pero no está limitado a unir solo conjuntos del mismo tipo de modelo.

El ensamblaje es una forma prácticamente garantizada de generalizar mejor un problema y de obtener un ligero impulso en el rendimiento. En algunos casos, el ensamblaje de modelos produce una importante aumento en el poder predictivo y, a veces, apenas leve. Esto depende del conjunto de datos en el que esté entrenando y evaluando, así como de los propios modelos.

La unión de árboles de decisión produce importante aumenta el rendimiento en comparación con los árboles individuales. Este enfoque se popularizó en las comunidades de investigación y aprendizaje automático aplicado, y era tan común que el conjunto de árboles de decisión se denominó coloquialmente como bosque, y el tipo común de bosque que se estaba creando (un bosque de árboles de decisión en un subconjunto aleatorio de características) popularizó el nombre bosques al azar.

Dado el uso a gran escala, las bibliotecas como Scikit-Learn han implementado contenedores para RandomForestRegressors y RandomForestClassifiers, construido sobre sus propias implementaciones de árboles de decisión, para permitir que los investigadores eviten construir sus propios conjuntos.

¡Sumerjámonos en bosques aleatorios!

¿Cómo funciona el algoritmo de bosque aleatorio?

Los siguientes son los pasos básicos involucrados al ejecutar el algoritmo de bosque aleatorio:

1. Elija una cantidad de registros aleatorios, puede ser cualquier número, como 4, 20, 76, 150 o incluso 2.000 del conjunto de datos (llamado N registros). El número dependerá del ancho del conjunto de datos, cuanto más ancho, más grande N puede ser. Aquí es donde el azar parte del nombre del algoritmo proviene!
2. Construya un árbol de decisión basado en esos N registros aleatorios;
3. De acuerdo con la cantidad de árboles definidos por el algoritmo, o la cantidad de árboles en el bosque, repita los pasos 1 y 2. Esto genera más árboles a partir de conjuntos de registros de datos aleatorios;
4. Después del paso 3, viene el paso final, que es predecir los resultados:
   • En caso de clasificación: cada árbol del bosque predecirá la categoría a la que pertenece el nuevo registro. Después de eso, el nuevo registro se asigna a la categoría que gana la mayoría de votos.
   • En caso de regresión: cada árbol del bosque predice un valor para el nuevo registro, y el valor de predicción final se calculará tomando un promedio de todos los valores pronosticados por todos los árboles del bosque.

Cada árbol que se ajuste a un subconjunto aleatorio de características necesariamente no tendrá conocimiento de algunas otras características, lo que se rectifica mediante el ensamblaje, manteniendo el costo computacional más bajo.

Con una intuición sobre cómo funcionan los árboles y una comprensión de los bosques aleatorios, ¡lo único que queda es practicar la construcción, el entrenamiento y el ajuste de los datos!

Creación y entrenamiento de modelos de bosques aleatorios con Scikit-Learn

Había una razón por la que los ejemplos utilizados hasta ahora involucran el embarazo, la vivienda y las mujeres.

En 2020, investigadores de Bangladesh notaron que la mortalidad entre las mujeres embarazadas aún era muy alta, especialmente considerando las que viven en áreas rurales. Por eso, usaron un sistema de monitoreo IOT para analizar el riesgo de la salud materna. El sistema IOT recopiló datos de diferentes hospitales, clínicas comunitarias y centros de salud materna de las áreas rurales de Bangladesh.

Luego, los datos recopilados se organizaron en un archivo de valores separados por comas (csv) y se cargaron en Repositorio de aprendizaje automático de UCI.

Estos son los datos que usaremos para practicar y tratar de entender si una mujer embarazada tiene un bajo, mediano or high riesgo de mortalidad.

Uso de bosques aleatorios para la clasificación

Como queremos saber si la mujer tiene bajo, mediano or high riesgo de mortalidad, esto quiere decir que haremos una clasificación con tres clases. Cuando un problema tiene más de dos clases, se le llama multiclase problema, a diferencia de un binario problema (donde elige entre dos clases, típicamente 0 y 1).

En este primer ejemplo, implementaremos un modelo de clasificación multiclase con un clasificador Random Forest y Scikit-Learn de Python.

Seguiremos los pasos habituales de aprendizaje automático para resolver este problema, que son cargar bibliotecas, leer los datos, observar estadísticas de resumen y crear visualizaciones de datos para comprenderlo mejor. Luego, preprocesar y dividir los datos seguidos de generar, entrenar y evaluar un modelo.

Importando Bibliotecas

Usaremos Pandas para leer los datos, Seaborn y Matplotlib para visualizarlos, y NumPy para los grandes métodos de utilidad:

import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt

Importación del conjunto de datos

El siguiente código importa el conjunto de datos y lo carga en Python DataFrame:

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Para mirar las primeras cinco líneas de los datos, ejecutamos el head() mando:

dataset.head()

Esto produce:

    Age SystolicBP  DiastolicBP BS      BodyTemp    HeartRate   RiskLevel
0   25  130         80          15.0    98.0        86          high risk
1   35  140         90          13.0    98.0        70          high risk
2   29  90          70          8.0     100.0       80          high risk
3   30  140         85          7.0     98.0        70          high risk
4   35  120         60          6.1     98.0        76          low risk

Aquí podemos ver todos los atributos recopilados durante la investigación.

• Edad: edades en años.
• PASistólica: valor superior de la Presión Arterial en mmHg, atributo significativo durante el embarazo.
• PA Diastólica: menor valor de la Presión Arterial en mmHg, otro atributo significativo durante el embarazo.
• BS: niveles de glucosa en sangre en términos de concentración molar, mmol/L.
• HeartRate: frecuencia cardíaca en reposo en latidos por minuto.
• RiskLevel: nivel de riesgo durante el embarazo.
• BodyTemp: la temperatura corporal.

Ahora que entendemos más acerca de lo que se mide, podemos ver los tipos de datos con info():

dataset.info()

Esto resulta en:

RangeIndex: 1014 entries, 0 to 1013
Data columns (total 7 columns):
 #   Column       Non-Null Count  Dtype  
---  ------       --------------  -----  
 0   Age          1014 non-null   int64  
 1   SystolicBP   1014 non-null   int64  
 2   DiastolicBP  1014 non-null   int64  
 3   BS           1014 non-null   float64
 4   BodyTemp     1014 non-null   float64
 5   HeartRate    1014 non-null   int64  
 6   RiskLevel    1014 non-null   object 
dtypes: float64(2), int64(4), object(1)
memory usage: 55.6+ KB

De mirar el RangeIndex línea, podemos ver que hay 1014 registros, y la columna Non-Null Count informa que los datos no tienen ningún valor faltante. ¡Esto significa que no necesitaremos hacer ningún tratamiento por los datos faltantes!

En Dtype columna, podemos ver el tipo de cada variable. Corrientemente, float64 columnas tales BS y BodyTemp tienen valores numéricos que pueden variar en cualquier rango, como 15.0, 15.51, 15.76, 17.28, haciéndolos numéricamente continuo (siempre puede agregar un 0 a un número de punto flotante, ad infinitem). Por otra parte, variables como Age, SystolicBP, DiastolicBPy HeartRate son del tipo int64, esto significa que los números solo cambian por la unidad, como 11, 12, 13, 14, no tendremos una frecuencia cardíaca de 77.78, es 77 o 78, esos son numéricamente discreto valores. Y también tenemos RiskLevel con un object type, esto suele indicar que la variable es un texto, y probablemente necesitemos transformarla en un número. Dado que el nivel de riesgo crece de menor a mayor, hay un orden implícito en las categorías, esto indica que es un categóricamente ordinal variable.

Después de ver los tipos de datos, podemos usar describe() para tomar un pico en algunas estadísticas descriptivas, como los valores medios de cada columna, la desviación estándar, los cuantiles, los valores de datos mínimos y máximos:

dataset.describe().T 

El código anterior muestra:

            count   mean        std         min     25%     50%     75%     max
Age         1014.0  29.871795   13.474386   10.0    19.0    26.0    39.0    70.0
SystolicBP  1014.0  113.198225  18.403913   70.0    100.0   120.0   120.0   160.0
DiastolicBP 1014.0  76.460552   13.885796   49.0    65.0    80.0    90.0    100.0
BS          1014.0  8.725986    3.293532    6.0     6.9     7.5     8.0     19.0
BodyTemp    1014.0  98.665089   1.371384    98.0    98.0    98.0    98.0    103.0
HeartRate   1014.0  74.301775   8.088702    7.0     70.0    76.0    80.0    90.0
RiskLevel   1014.0  0.867850    0.807353    0.0     0.0     1.0     2.0     2.0

Observe que para la mayoría de las columnas, el personalizado Los valores están lejos de los desviación estándar (estándar) – esto indica que los datos no siguen necesariamente una distribución estadística de buen comportamiento. Si lo hubiera hecho, habría ayudado al modelo a predecir el riesgo. Lo que se puede hacer aquí es preprocesar los datos para hacerlos más representativos como si fueran datos de toda la población mundial, o más normalizado. Pero, una ventaja cuando se usan modelos Random Forest para clasificación, es que la estructura de árbol inherente puede manejar bien los datos que no han sido normalizados, una vez que los divide por el valor en cada nivel de árbol para cada variable.

Además, debido a que estamos usando árboles y que la clase resultante se obtendrá votando, no estamos comparando inherentemente entre diferentes valores, solo entre los mismos tipos de valores, por lo que no es necesario ajustar las características a la misma escala en este caso. . Esto significa que el modelo de clasificación Random Forest es escala invariante, y no necesita realizar escalado de características.

En este caso, el paso en el preprocesamiento de datos que podemos dar es transformar el categórico RiskLevel columna en una numérica.

Visualización de los datos

Antes de transformar RiskLevel, también visualicemos rápidamente los datos observando las combinaciones de puntos para cada par de características con un diagrama de dispersión y cómo se distribuyen los puntos visualizando la curva de histograma. Para hacer eso, usaremos Seaborn's pairplot() que combina ambas parcelas. Genera ambos gráficos para cada combinación de características y muestra los puntos codificados por colores según su nivel de riesgo con el hue propiedad:

g = sns.pairplot(dataset, hue='RiskLevel')
g.fig.suptitle("Scatterplot and histogram of pairs of variables color coded by risk level", 
               fontsize = 14, 
               y=1.05); 

El código anterior genera:

Al observar el gráfico, la situación ideal sería tener una separación clara entre curvas y puntos. Como podemos ver, los tres tipos de clases de riesgo se mezclan en su mayoría, ya que los árboles dibujan líneas internamente al delimitar los espacios entre los puntos, podemos suponer que más árboles en el bosque podrían delimitar más espacios y clasificar mejor los puntos.

Con el análisis de datos exploratorio básico hecho, podemos preprocesar el RiskLevel columna.

Preprocesamiento de datos para clasificación

Para estar seguro de que sólo hay tres clases de RiskLevel en nuestros datos, y que no se han agregado otros valores erróneamente, podemos usar unique() para mostrar los valores únicos de la columna:

dataset['RiskLevel'].unique()

Esto produce:

array(['high risk', 'low risk', 'mid risk'], dtype=object)

Las clases están marcadas, ahora el siguiente paso es transformar cada valor en un número. Dado que existe un orden entre las clasificaciones, podemos usar los valores 0, 1 y 2 para indicar bajo, mediano y high riesgos Hay muchas formas de cambiar los valores de las columnas, siguiendo las de Python. simple es mejor que complejo lema, usaremos el .replace() y simplemente reemplácelos con sus representaciones enteras:

dataset['RiskLevel'] = dataset['RiskLevel'].replace('low risk', 0).replace('mid risk', 1).replace('high risk', 2)

Después de reemplazar los valores, podemos dividir los datos en lo que se usará para entrenar el modelo, el Características or X, y lo que queremos predecir, la etiquetas or y:

y = dataset['RiskLevel']
X = dataset.drop(['RiskLevel'], axis=1)

Una vez que la X y y los conjuntos están listos, podemos usar Scikit-Learn's train_test_split() método para dividirlos aún más en el tren y los conjuntos de prueba:

from sklearn.model_selection import train_test_split

SEED = 42
X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Aquí, estamos usando el 20 % de los datos para pruebas y el 80 % para entrenamiento.

Entrenamiento de un RandomForestClassifier

Scikit-Learn implementó conjuntos bajo el sklearn.ensemble módulo. Un conjunto de árboles de decisión utilizados para la clasificación, en los que se toma una mayoría de votos, se implementa como el RandomForestClassifier.

Teniendo los conjuntos de tren y prueba, podemos importar el RandomForestClassifier clase y crear el modelo. Para empezar, creemos un bosque con tres árboles, configurando n_estimators parámetro como 3, y con cada árbol que tiene tres niveles, configurando max_deptha 2:

from sklearn.ensemble import RandomForestClassifier

rfc = RandomForestClassifier(n_estimators=3, 
                             max_depth=2,
                             random_state=SEED)

Para ajustar el modelo alrededor de los datos, llamamos al fit() método, pasando las características y etiquetas de entrenamiento:

rfc.fit(X_train, y_train)

y_pred = rfc.predict(X_test)

¡Ahora podemos comparar las etiquetas pronosticadas con las etiquetas reales para evaluar qué tan bien funcionó el modelo! Antes de evaluar el modelo, echemos un vistazo al conjunto.

Para profundizar un poco más en el modelo, podemos visualizar cada uno de los árboles y cómo están dividiendo los datos. Esto se puede hacer usando el tree módulo integrado en Scikit-Learn, y luego recorrer cada uno de los estimadores en el conjunto:

from sklearn import tree

features = X.columns.values 
classes = ['0', '1', '2'] 



for estimator in rfc.estimators_:
    print(estimator)
    plt.figure(figsize=(12,6))
    tree.plot_tree(estimator,
                   feature_names=features,
                   class_names=classes,
                   fontsize=8, 
                   filled=True, 
                   rounded=True)
    plt.show()

El código anterior muestra los diagramas de árbol:

Observe cómo los tres árboles son diferentes. El primero comienza con el BS característica, la segunda con DiastolicBP, y el tercero con BS otra vez. Aunque el tercero analiza un número diferente de muestras. En la rama derecha, los dos primeros árboles también deciden usando Age al nivel de la hoja, mientras que el tercer árbol termina con BS rasgo. Con solo tres estimadores, está claro cómo la ampliación brinda una representación rica y diversa del conocimiento que se puede ensamblar con éxito en un modelo de alta precisión.

Cuantos más árboles haya en el bosque, más diverso puede ser el modelo. Sin embargo, hay un punto de rendimientos decrecientes, ya que con muchos árboles que encajan en un subconjunto aleatorio de características, habrá una buena cantidad de árboles similares que no ofrecen mucha diversidad en el conjunto, y que comenzarán a tener demasiado poder de voto y sesgar el conjunto para que se sobreajuste en el conjunto de datos de entrenamiento, perjudicando la generalización al conjunto de validación.

Anteriormente se hizo una hipótesis sobre tener más árboles y cómo podría mejorar los resultados del modelo. ¡Echemos un vistazo a los resultados, generemos un nuevo modelo y veamos si la hipótesis se mantiene!

Evaluación de RandomForestClassifier

Scikit-Learn facilita la creación de líneas base al proporcionar un DummyClassifier, que genera predicciones sin utilizar las funciones de entrada (salidas totalmente aleatorias). Si su modelo es mejor que el DummyClassifier, algo ¡el aprendizaje está sucediendo! Para maximizar el aprendizaje, puede probar varios hiperparámetros automáticamente usando un RandomizedSearchCV or GridSearchCV. Además de tener una línea de base, puede evaluar el rendimiento de su modelo desde el punto de vista de varias métricas.

Algunas métricas de clasificación tradicionales que se pueden usar para evaluar el algoritmo son precisión, recuperación, puntaje f1, precisión y matriz de confusión. Aquí hay una breve explicación sobre cada uno de ellos:

1. Precisión: cuando nuestro objetivo es entender qué valores de predicción correctos fueron considerados correctos por nuestro clasificador. La precisión dividirá esos valores positivos verdaderos por las muestras que se pronosticaron como positivas;

$$
precision = frac{texto{verdaderos positivos}}{texto{verdaderos positivos} + texto{falsos positivos}}
$$

2. Recordar: comúnmente calculado junto con precisión para comprender cuántos de los verdaderos positivos fueron identificados por nuestro clasificador. El recuerdo se calcula dividiendo los verdaderos positivos por cualquier cosa que debería haber sido pronosticada como positiva.

$$
recordar = frac{texto{verdaderos positivos}}{texto{verdaderos positivos} + texto{falsos negativos}}
$$

3. Puntuación F1: es el equilibrado o Significado armonico de precisión y recuerdo. El valor más bajo es 0 y el más alto es 1. Cuando f1-score es igual a 1, significa que todas las clases se predijeron correctamente; esta es una puntuación muy difícil de obtener con datos reales (casi siempre existen excepciones).

$$
texto{f1-score} = 2* frac{texto{precisión} * texto{recordar}}{texto{precisión} + texto{recordar}}
$$

4. Matriz de confusión: cuando necesitamos saber para cuántas muestras obtuvimos bien o mal cada clase. Los valores que fueron correctos y correctamente predichos se llaman verdaderos positivos, los que se pronosticaron como positivos pero no lo fueron se llaman falsos positivos. La misma nomenclatura de verdaderos negativos y falsos negativos se utiliza para valores negativos;

5. Exactitud: describe cuántas predicciones acertó nuestro clasificador. El valor de precisión más bajo es 0 y el más alto es 1. Ese valor se suele multiplicar por 100 para obtener un porcentaje:

$$
precision = frac{texto{número de predicciones correctas}}{texto{número total de predicciones}}
$$

Puede ejecutar el siguiente script para importar las bibliotecas necesarias y ver los resultados:

from sklearn.metrics import classification_report, confusion_matrix

cm = confusion_matrix(y_test, y_pred)
sns.heatmap(cm, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk)')

print(classification_report(y_test,y_pred))

La salida se verá así:

                precision    recall  f1-score   support

           0       0.53      0.89      0.66        80
           1       0.57      0.17      0.26        76
           2       0.74      0.72      0.73        47

    accuracy                           0.58       203
   macro avg       0.61      0.59      0.55       203
weighted avg       0.59      0.58      0.53       203

En el informe de clasificación, observe que el recuerdo es alto, 0.89 para la clase 0, tanto la precisión como el recuerdo son altos para la clase 2, 0.74, 0.72 y para la clase 1 son bajos, especialmente el recuerdo de 0.17 y una precisión de 0.57. . La relación entre el recuerdo y la precisión para las tres clases individualmente se captura en el F1 puntuación, que es la media armónica entre el recuerdo y la precisión: el modelo está haciendo bien para la clase 0, bastante malo para la clase 1 y decente para la clase 2.

La modelo lo está pasando muy mal a la hora de identificar el casos de riesgo medio.

La precisión alcanzada por nuestro clasificador de bosques aleatorios con solo 3 árboles es de 0.58 (58%): esto significa que está obteniendo un poco más de la mitad de los resultados correctos. Esta es una precisión baja, y quizás podría mejorarse agregando más árboles.

Al observar la matriz de confusión, podemos ver que la mayoría de los errores se producen al clasificar 52 registros de riesgo medio como de riesgo bajo, lo que da una idea más clara del recuerdo bajo de la clase 1. Está sesgado hacia la clasificación de pacientes de riesgo medio como de riesgo bajo. pacientes de riesgo.

Otra cosa que se puede verificar para generar aún más información es qué características tiene más en cuenta el clasificador al predecir. Este es un paso importante a tomar para sistemas explicables de aprendizaje automáticoy ayuda a identificar y mitigar el sesgo en los modelos.

Para verlo, podemos acceder a la feature_importances_ propiedad del clasificador. Esto nos dará una lista de porcentajes, por lo que también podemos acceder a la feature_names_in_ property para obtener el nombre de cada función, organizarlas en un marco de datos, ordenarlas de mayor a menor y trazar el resultado:

features_df = pd.DataFrame({'features': rfc.feature_names_in_, 'importances': rfc.feature_importances_ })


features_df_sorted = features_df.sort_values(by='importances', ascending=False)


g = sns.barplot(data=features_df_sorted, x='importances', y ='features', palette="rocket")
sns.despine(bottom = True, left = True)
g.set_title('Feature importances')
g.set(xlabel=None)
g.set(ylabel=None)
g.set(xticks=[])
for value in g.containers:
    g.bar_label(value, padding=2)

Observe cómo el clasificador considera principalmente el glicemia, luego un poco de la presión diastólica, la temperatura corporal y solo un poco de la edad para tomar una decisión, esto también podría tener que ver con el recuerdo bajo en la clase 1, tal vez los datos de riesgo medio tienen que ver con características que no se están tomando tenido muy en cuenta por el modelo. Puede intentar jugar más con la importancia de las funciones para investigar esto y ver si los cambios en el modelo afectan las funciones que se utilizan, también si existe una relación significativa entre algunas de las funciones y las clases predichas.

Finalmente es hora de generar un nuevo modelo con más árboles para ver cómo afecta los resultados. Vamos a crear el rfc_ Bosque con 900 árboles, 8 niveles y la misma semilla. ¿Mejorarán los resultados?

rfc_ = RandomForestClassifier(n_estimators=900, 
                             max_depth=7,
                             random_state=SEED)
rfc_.fit(X_train, y_train)
y_pred = rfc_.predict(X_test)

Cálculo y visualización de las métricas:

cm_ = confusion_matrix(y_test, y_pred)
sns.heatmap(cm_, annot=True, fmt='d').set_title('Maternal risks confusion matrix (0 = low risk, 1 = medium risk, 2 = high risk) for 900 trees with 8 levels')

print(classification_report(y_test,y_pred))

Esto produce:

                precision    recall  f1-score   support

           0       0.68      0.86      0.76        80
           1       0.75      0.58      0.65        76
           2       0.90      0.81      0.85        47

    accuracy                           0.74       203
   macro avg       0.78      0.75      0.75       203
weighted avg       0.76      0.74      0.74       203

Esto muestra cómo agregar más árboles y árboles más especializados (niveles más altos) ha mejorado nuestras métricas. Todavía tenemos un recuerdo bajo para la clase 1, pero la precisión ahora es del 74 %. La puntuación F1 al clasificar los casos de alto riesgo es de 0.85, lo que significa que los casos de alto riesgo ahora se identifican más fácilmente en comparación con el 0.73 del modelo anterior.

En un proyecto del día a día, puede ser más importante identificar los casos de alto riesgo, por ejemplo, con una métrica similar a la precisión, que también se conoce como sensibilidad en estadísticas. Intente ajustar algunos de los parámetros del modelo y observe los resultados.

Hasta ahora, hemos obtenido una comprensión general de cómo se puede usar Random Forest para clasificar datos; en la siguiente sección, podemos usar el mismo conjunto de datos de una manera diferente para ver cómo el mismo modelo predice valores con regresión.

Uso de bosques aleatorios para la regresión

En esta sección estudiaremos cómo se puede usar un algoritmo Random Forest para resolver problemas de regresión usando Scikit-Learn. Los pasos seguidos para implementar este algoritmo son casi idénticos a los pasos realizados para la clasificación, además del tipo de modelo y tipo de datos pronosticados, que ahora serán valores continuos, solo hay una diferencia en la preparación de datos.

Como la regresión se hace para valores numéricos – vamos a elegir un valor numérico del conjunto de datos. Hemos visto que el azúcar en la sangre era importante en la clasificación, por lo que debería ser predecible en función de otras características (ya que si se correlaciona con alguna característica, esa característica también se correlaciona con ella).

Siguiendo lo que hemos hecho para la clasificación, primero importemos las bibliotecas y el mismo conjunto de datos. Si ya hizo esto para el modelo de clasificación, puede omitir esta parte e ir directamente a la preparación de datos para el entrenamiento.

Importación de bibliotecas y datos

import pandas as pd
import numpy as np
import maplotlib.pyplot as plt
import seaborn as sns

dataset = pd.read_csv("../../datasets/random-forest/maternal_health_risk.csv")

Preprocesamiento de datos para regresión

Esta es una tarea de regresión, por lo que en lugar de predecir clases, podemos predecir una de las columnas numéricas del conjunto de datos. En este ejemplo, el BS se pronosticará la columna. esto significa que y los datos contendrán datos de azúcar en la sangrey X los datos contendrán todas las características además del azúcar en la sangre. Después de separar el X y y datos, podemos dividir el tren y los conjuntos de prueba:

from sklearn.model_selection import train_test_split

SEED = 42

y = dataset['BS']
X = dataset.drop(['BS'], axis=1) 

X_train, X_test, y_train, y_test = train_test_split(X, y, 
                                                    test_size=0.2, 
                                                    random_state=SEED)

Entrenando un RandomForestRegressor

Ahora que hemos escalado nuestro conjunto de datos, es hora de entrenar nuestro algoritmo para resolver este problema de regresión, para cambiarlo un poco: crearemos un modelo con 20 árboles en el bosque y cada uno con 4 niveles. Para hacerlo, puedes ejecutar el siguiente código:

from sklearn.ensemble import RandomForestRegressor

rfr = RandomForestRegressor(n_estimators=20, 
                            max_depth=3, 
                            random_state=SEED)

rfr.fit(X_train, y_train)
y_pred = rfr.predict(X_test)

Puede encontrar detalles de todos los parámetros de RandomForestRegressor en la documentación oficial.

Dado que trazar y observar 20 árboles requeriría algo de tiempo y dedicación, podemos trazar solo el primero para ver en qué se diferencia del árbol de clasificación:

from sklearn import tree

features = X.columns

first_tree = rfr.estimators_[0]

plt.figure(figsize=(15,6))
tree.plot_tree(first_tree,
               feature_names=features,
               fontsize=8, 
               filled=True, 
               rounded=True);

Observe que el árbol de regresión ya tiene un valor asignado a los datos que se encuentran en cada nodo. Esos son los valores que se promediarán al combinar los 20 árboles. Siguiendo lo que hemos hecho con la clasificación, también puede trazar la importancia de las características para ver qué variables tiene más en cuenta el modelo de regresión al calcular los valores.

¡Es hora de continuar con el último y último paso al resolver un problema de aprendizaje automático y evaluar el rendimiento del algoritmo!

Evaluación de un RandomForestRegressor

Para los problemas de regresión, las métricas utilizadas para evaluar un algoritmo son el error absoluto medio (MAE), el error cuadrático medio (MSE) y el error cuadrático medio (RMSE).

1. Error absoluto medio (MAE): cuando restamos los valores predichos de los valores reales, obteniendo los errores, sumamos los valores absolutos de esos errores y obtenemos su media. Esta métrica da una noción del error global para cada predicción del modelo, cuanto menor (más cercano a 0) mejor.

$$
mae = (frac{1}{n})sum_{i=1}^{n}izquierda | Actual – Correcto previsto |
$$

2. Error cuadrático medio (MSE): es similar a la métrica MAE, pero eleva al cuadrado los valores absolutos de los errores. Además, al igual que con MAE, cuanto más pequeño o más cercano a 0, mejor. El valor de MSE se eleva al cuadrado para que los errores grandes sean aún mayores. Una cosa a la que hay que prestar mucha atención es que suele ser una métrica difícil de interpretar debido al tamaño de sus valores y al hecho de que no están en la misma escala de los datos.

$$
mse = sum_{i=1}^{D}(Real – Predicho)^2
$$

3. Error cuadrático medio (RMSE): trata de resolver el problema de interpretación planteado con el MSE sacando la raíz cuadrada de su valor final, para escalarlo a las mismas unidades de los datos. Es más fácil de interpretar y bueno cuando necesitamos mostrar o mostrar el valor real de los datos con el error. Muestra cuánto pueden variar los datos, por lo que, si tenemos un RMSE de 4.35, nuestro modelo puede cometer un error porque agregó 4.35 al valor real o porque necesitó 4.35 para llegar al valor real. Cuanto más cerca de 0, mejor también.

$$
rmse = sqrt{ sum_{i=1}^{D}(Real – Predicho)^2}
$$

Podemos usar cualquiera de esas tres métricas para comparar modelos (si tenemos que elegir uno). También podemos comparar el mismo modelo de regresión con diferentes valores de argumento o con diferentes datos y luego considerar las métricas de evaluación. Esto se conoce como ajuste de hiperparámetros – ajustar los hiperparámetros que influyen en un algoritmo de aprendizaje y observar los resultados.

A la hora de elegir entre modelos, los que tienen menos errores suelen rendir mejor. Al monitorear modelos, si las métricas empeoraron, entonces una versión anterior del modelo fue mejor, o hubo alguna alteración significativa en los datos para que el modelo funcionara peor de lo que estaba funcionando.

Puede usar el siguiente código para encontrar estos valores:

from sklearn.metrics import mean_absolute_error, mean_squared_error

print('Mean Absolute Error:', mean_absolute_error(y_test, y_pred))
print('Mean Squared Error:', mean_squared_error(y_test, y_pred))
print('Root Mean Squared Error:', np.sqrt(mean_squared_error(y_test, y_pred)))

La salida debe ser:

Mean Absolute Error: 1.127893702896059
Mean Squared Error: 3.0802988503933326
Root Mean Squared Error: 1.755078018320933

Con 20 árboles, el error cuadrático medio es de 1.75, que es bajo, pero aun así, al aumentar la cantidad de árboles y experimentar con los otros parámetros, este error probablemente podría reducirse aún más.

Ventajas de usar Random Forest

Como con cualquier algoritmo, hay ventajas y desventajas al usarlo. En las siguientes dos secciones, veremos los pros y los contras de usar un bosque aleatorio para la clasificación y la regresión.

1. El algoritmo de bosque aleatorio no está sesgado, ya que hay varios árboles y cada árbol se entrena en un subconjunto aleatorio de datos. Básicamente, el algoritmo del bosque aleatorio se basa en el poder de "la multitud"; por lo tanto, se reduce el grado general de sesgo del algoritmo.
2. Este algoritmo es muy estable. Incluso si se introduce un nuevo punto de datos en el conjunto de datos, el algoritmo general no se ve muy afectado, ya que los nuevos datos pueden afectar a un árbol, pero es muy difícil que afecte a todos los árboles.
3. El algoritmo de bosque aleatorio funciona bien cuando tiene características categóricas y numéricas.
4. El algoritmo de bosque aleatorio también funciona bien cuando a los datos les faltan valores o no se han escalado.

Desventajas de usar Random Forest

1. La principal desventaja de los bosques aleatorios radica en su complejidad. Requieren muchos más recursos computacionales, debido a la gran cantidad de árboles de decisión unidos, cuando se entrenan grandes conjuntos. Sin embargo, con el hardware moderno, entrenar incluso un gran bosque aleatorio no lleva mucho tiempo.

Yendo más allá: proyecto portátil de extremo a extremo

¿Tu naturaleza inquisitiva te hace querer ir más allá? Recomendamos revisar nuestro Proyecto Guiado: “Predicción práctica del precio de la vivienda: aprendizaje automático en Python”.

En este proyecto guiado, aprenderá a crear potentes modelos tradicionales de aprendizaje automático, así como modelos de aprendizaje profundo, utilizar Ensemble Learning y capacitar a los meta-aprendices para predecir los precios de la vivienda a partir de una bolsa de modelos Scikit-Learn y Keras.

Usando Keras, la API de aprendizaje profundo construida sobre Tensorflow, experimentaremos con arquitecturas, construiremos un conjunto de modelos apilados y entrenaremos un meta-aprendiz red neuronal (modelo de nivel 1) para calcular el precio de una casa.

El aprendizaje profundo es sorprendente, pero antes de recurrir a él, se recomienda intentar resolver el problema con técnicas más simples, como con aprendizaje superficial algoritmos Nuestro rendimiento de referencia se basará en un Regresión de bosque aleatorio algoritmo. Además, exploraremos la creación de conjuntos de modelos a través de Scikit-Learn a través de técnicas como harpillera y votación.

Este es un proyecto integral y, como todos los proyectos de Machine Learning, comenzaremos con: con Análisis exploratorio de datos (XNUMX %) Preprocesamiento de datos y finalmente edificio poco profundo y Modelos de aprendizaje profundo para ajustarse a los datos que hemos explorado y limpiado previamente.