Algoritmo de bosque aleatorio con Python y Scikit-Learn

    El bosque aleatorio es un tipo de algoritmo de Machine Learning supervisado basado en aprendizaje conjunto. El aprendizaje conjunto es un tipo de aprendizaje en el que se combinan diferentes tipos de algoritmos o el mismo algoritmo varias veces para formar un modelo de predicción más potente. los Random Forest El algoritmo combina varios algoritmos del mismo tipo, es decir, varios árboles de decisión, lo que da como resultado un bosque de árboles, de ahí el nombre “Bosque aleatorio”. El algoritmo de bosque aleatorio se puede utilizar para tareas de regresión y clasificación.

    Cómo funciona el algoritmo de bosque aleatorio

    Los siguientes son los pasos básicos involucrados en la realización del algoritmo de bosque aleatorio:

    • Elija N registros aleatorios del conjunto de datos.
    • Cree un árbol de decisiones basado en estos N registros.
    • Elija la cantidad de árboles que desee en su algoritmo y repita los pasos 1 y 2.
    • En caso de un problema de regresión, para un nuevo registro, cada árbol del bosque predice un valor para Y (salida). El valor final se puede calcular tomando el promedio de todos los valores predichos por todos los árboles del bosque. O, en caso de un problema de clasificación, cada árbol del bosque predice la categoría a la que pertenece el nuevo registro. Finalmente, el nuevo récord se asigna a la categoría que obtiene la mayoría de votos.

    Ventajas de usar Random Forest

    Como con cualquier algoritmo, existen 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 regresión.

    • El algoritmo de bosque aleatorio no está sesgado, ya que hay varios árboles y cada árbol se entrena en un subconjunto de datos. Básicamente, el algoritmo de bosque aleatorio se basa en el poder de “la multitud”; por lo tanto, se reduce el sesgo general del algoritmo.
    • 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 afecten a todos los árboles.
    • El algoritmo de bosque aleatorio funciona bien cuando tiene características tanto categóricas como numéricas.
    • El algoritmo de bosque aleatorio también funciona bien cuando a los datos les faltan valores o no se han escalado bien (aunque hemos realizado el escalado de características en este artículo solo con el propósito de demostración).

    Desventajas de usar Random Forest

    • Una gran desventaja de los bosques aleatorios radica en su complejidad. Necesitaron muchos más recursos computacionales, debido a la gran cantidad de árboles de decisión unidos.
    • Debido a su complejidad, requieren mucho más tiempo para entrenarse que otros algoritmos comparables.

    A lo largo del resto de este artículo, veremos cómo Python Biblioteca Scikit-Learn se puede utilizar para implementar el algoritmo de bosque aleatorio para resolver problemas de regresión, así como de clasificación.

    Parte 1: uso de bosque aleatorio para la regresión

    En esta sección, estudiaremos cómo se pueden usar los bosques aleatorios para resolver problemas de regresión usando Scikit-Learn. En la siguiente sección resolveremos el problema de clasificación a través de bosques aleatorios.

    Definición del problema

    El problema aquí es predecir el consumo de gas (en millones de galones) en 48 de los estados de EE. UU. Con base en el impuesto a la gasolina (en centavos), el ingreso per cápita (dólares), las carreteras pavimentadas (en millas) y la proporción de la población con el licencia de conducir.

    Solución

    Para resolver este problema de regresión usaremos el algoritmo de bosque aleatorio a través de la biblioteca de Python de Scikit-Learn. Seguiremos el proceso tradicional de Machine Learning para resolver este problema. Sigue estos pasos:

    1. Importar bibliotecas

    Ejecute el siguiente código para importar las bibliotecas necesarias:

    import pandas as pd
    import numpy as np
    

    2. Importación de conjunto de datos

    El conjunto de datos de este problema está disponible en:

    https://drive.google.com/file/d/1mVmGNx6cbfvRHC_DvF12ZL3wGLSHD9f_/view

    Por el bien de este tutorial, el conjunto de datos se ha descargado en la carpeta “Conjuntos de datos” de la unidad “D”. Deberá cambiar la ruta del archivo según su propia configuración.

    Ejecute el siguiente comando para importar el conjunto de datos:

    dataset = pd.read_csv('D:Datasetspetrol_consumption.csv')
    

    Para obtener una vista de alto nivel de cómo se ve el conjunto de datos, ejecute el siguiente comando:

    dataset.head()
    

    Gasolina_impuestos Ingresos_medios Autopistas_ pavimentadas Población_Licencia_controlador (%) Consumo_de_ gasolina
    01234

    9.0357119760.525541
    9.0409212500.572524
    9.0386515860.580561
    7.5487023510.529414
    8.043994310.544410

    Podemos ver que los valores en nuestro conjunto de datos no están muy bien escalados. Los reduciremos antes de entrenar el algoritmo.

    3. Preparación de datos para la formación

    En esta sección se realizarán dos tareas. La primera tarea es dividir los datos en conjuntos de “atributos” y “etiquetas”. Los datos resultantes luego se dividen en conjuntos de entrenamiento y prueba.

    La siguiente secuencia de comandos divide los datos en atributos y etiquetas:

    X = dataset.iloc[:, 0:4].values
    y = dataset.iloc[:, 4].values
    

    Finalmente, dividamos los datos en conjuntos de entrenamiento y prueba:

    from sklearn.model_selection import train_test_split
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    

    4. Escala de funciones

    Sabemos que nuestro conjunto de datos aún no es un valor escalado, por ejemplo, el campo Average_Income tiene valores en el rango de miles, mientras que Petrol_tax tiene valores en el rango de decenas. Por lo tanto, sería beneficioso escalar nuestros datos (aunque, como se mencionó anteriormente, este paso no es tan importante para el algoritmo de bosques aleatorios). Para hacerlo, usaremos Scikit-Learn’s StandardScaler clase. Ejecute el siguiente código para hacerlo:

    # Feature Scaling
    from sklearn.preprocessing import StandardScaler
    
    sc = StandardScaler()
    X_train = sc.fit_transform(X_train)
    X_test = sc.transform(X_test)
    

    5. Entrenamiento del algoritmo

    Ahora que hemos escalado nuestro conjunto de datos, es hora de entrenar nuestro algoritmo de bosque aleatorio para resolver este problema de regresión. Ejecute el siguiente código:

    from sklearn.ensemble import RandomForestRegressor
    
    regressor = RandomForestRegressor(n_estimators=20, random_state=0)
    regressor.fit(X_train, y_train)
    y_pred = regressor.predict(X_test)
    

    los RandomForestRegressor clase de la sklearn.ensemble La biblioteca se utiliza para resolver problemas de regresión mediante un bosque aleatorio. El parámetro más importante de la RandomForestRegressor la clase es la n_estimators parámetro. Este parámetro define la cantidad de árboles en el bosque aleatorio. Empezaremos con n_estimator=20 para ver cómo funciona nuestro algoritmo. Puede encontrar detalles de todos los parámetros de RandomForestRegressor aquí.

    6. Evaluación del algoritmo

    El último y último paso para resolver un problema de Machine Learning es evaluar el rendimiento del algoritmo. Para problemas de regresión, las métricas que se utilizan para evaluar un algoritmo son el error absoluto medio, el error cuadrático medio y el error cuadrático medio. Ejecute el siguiente código para encontrar estos valores:

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

    La salida se verá así:

    Mean Absolute Error: 51.765
    Mean Squared Error: 4216.16675
    Root Mean Squared Error: 64.932016371
    

    Con 20 árboles, el error cuadrático medio es 64,93, que es superior al 10 por ciento del consumo medio de gasolina, es decir, 576,77. Esto puede indicar, entre otras cosas, que no hemos utilizado suficientes estimadores (árboles).

    Si el número de estimadores se cambia a 200, los resultados son los siguientes:

    Mean Absolute Error: 47.9825
    Mean Squared Error: 3469.7007375
    Root Mean Squared Error: 58.9041657058
    

    El siguiente gráfico muestra la disminución en el valor de la error cuadrático medio (RMSE) con respecto al número de estimadores. Aquí el El eje X contiene el número de estimadores mientras que la El eje Y contiene el valor del error cuadrático medio de la raíz.

    Puede ver que los valores de error disminuyen con el aumento en el número de estimadores. Después de 200, la tasa de disminución del error disminuye, por lo que 200 es un buen número para n_estimators. Puede jugar con la cantidad de árboles y otros parámetros para ver si puede obtener mejores resultados por su cuenta.

    Parte 2: Uso del bosque aleatorio para la clasificación

    Definición del problema

    La tarea aquí es predecir si un billete de moneda bancaria es auténtico o no basándose en cuatro atributos, es decir, la varianza de la imagen transformada en ondas, la asimetría, la entropía y la curtosis de la imagen.

    Solución

    Este es un problema de clasificación binaria y usaremos un clasificador de bosque aleatorio para resolver este problema. Los pasos seguidos para resolver este problema serán similares a los pasos realizados para la regresión.

    1. Importar bibliotecas

    import pandas as pd
    import numpy as np
    

    2. Importar conjunto de datos

    El conjunto de datos se puede descargar desde el siguiente enlace:

    https://drive.google.com/file/d/13nw-uRXPY8XIZQxKRNZ3yYlho-CYm_Qt/view

    La información detallada sobre los datos está disponible en el siguiente enlace:

    https://archive.ics.uci.edu/ml/datasets/banknote+authentication

    El siguiente código importa el conjunto de datos:

    dataset = pd.read_csv("D:/Datasets/bill_authentication.csv")
    

    Para obtener una vista de alto nivel del conjunto de datos, ejecute el siguiente comando:

    dataset.head()
    

    Clase de entropía de curtosis de asimetría de varianza
    01234

    3.621608.6661-2,8073-0,446990
    4.545908.1674-2,4586-1.462100
    3.86600-2,63831.92420.106450
    3.456609.5228-4.0112-3.594400
    0.32924-4.45524.5718-0,988800

    Como fue el caso con el conjunto de datos de regresión, los valores en este conjunto de datos no están muy bien escalados. El conjunto de datos se escalará antes de entrenar el algoritmo.

    3. Preparación de datos para la formación

    El siguiente código divide los datos en atributos y etiquetas:

    X = dataset.iloc[:, 0:4].values
    y = dataset.iloc[:, 4].values
    

    El siguiente código divide los datos en conjuntos de entrenamiento y prueba:

    from sklearn.model_selection import train_test_split
    
    X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
    

    4. Escala de funciones

    Como antes, el escalado de características funciona de la misma manera:

    # Feature Scaling
    from sklearn.preprocessing import StandardScaler
    
    sc = StandardScaler()
    X_train = sc.fit_transform(X_train)
    X_test = sc.transform(X_test)
    

    5. Entrenamiento del algoritmo

    Y nuevamente, ahora que hemos escalado nuestro conjunto de datos, podemos entrenar nuestros bosques aleatorios para resolver este problema de clasificación. Para hacerlo, ejecute el siguiente código:

    from sklearn.ensemble import RandomForestRegressor
    
    regressor = RandomForestRegressor(n_estimators=20, random_state=0)
    regressor.fit(X_train, y_train)
    y_pred = regressor.predict(X_test)
    

    En caso de regresión usamos el RandomForestRegressor clase de la biblioteca sklearn.ensemble. Para la clasificación, haremos RandomForestClassifier clase de la biblioteca sklearn.ensemble. RandomForestClassifier la clase también toma n_estimators como parámetro. Como antes, este parámetro define la cantidad de árboles en nuestro bosque aleatorio. Empezaremos con 20 árboles nuevamente. Puede encontrar detalles de todos los parámetros de RandomForestClassifier aquí.

    6. Evaluación del algoritmo

    Para los problemas de clasificación, las métricas que se utilizan para evaluar un algoritmo son la precisión, la matriz de confusión, la recuperación de precisión y los valores F1. Ejecute la siguiente secuencia de comandos para encontrar estos valores:

    from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
    
    print(confusion_matrix(y_test,y_pred))
    print(classification_report(y_test,y_pred))
    print(accuracy_score(y_test, y_pred))
    

    La salida se verá así:

    [[155    2]
        1  117]]
                  precision   recall   f1-score   support
    
               0       0.99     0.99       0.99       157
               1       0.98     0.99       0.99       118
    
     avg / total       0.99     0.99       0.99       275
    
    0.989090909091
    

    La precisión alcanzada por nuestro clasificador de bosques aleatorio con 20 árboles es del 98,90%. A diferencia de antes, cambiar el número de estimadores para este problema no mejoró significativamente los resultados, como se muestra en el siguiente cuadro. Aquí, el eje X contiene el número de estimadores, mientras que el eje Y muestra la precisión.

    El 98,90% es una precisión bastante buena, por lo que no tiene mucho sentido aumentar nuestro número de estimadores de todos modos. Podemos ver que aumentar el número de estimadores no mejoró más la precisión.

    Para mejorar la precisión, le sugiero que juegue con otros parámetros del RandomForestClassifier clase y vea si puede mejorar nuestros resultados.

     

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *