Guía para desarrolladores de Random Forest: 5 formas de implementarlo en Python

Random Forest, un conjunto de árboles de decisión, es uno de los métodos más populares en la mundo del aprendizaje automático y se utiliza a menudo para hacer predicciones. En este artículo, vamos a discutir 5 diferentes paquetes de Python que puede utilizar para implementar Random Forest.

Empecemos por cómo se puede implementar un bosque aleatorio en Python sin utilizar paquetes.

Implementación de un bosque aleatorio en Python

Un Random Forest consiste en una colección de árboles de decisión. El algoritmo muestrea aleatoriamente los datos y variables de entrenamiento y crea un árbol de decisión a partir de cada muestra. La predicción se realiza promediando o haciendo coincidir las predicciones de los árboles individuales.

Este ejemplo de código implementa el algoritmo Random Forest en Python. El objetivo del algoritmo es generar un conjunto de árboles de decisión y aumentar la precisión de la predicción agregando sus predicciones.

Implementación en Python puro de un bosque aleatorio

El código comienza importando las bibliotecas necesarias, a saber, numpy y collections. Además, se importa el módulo dataset de Scikit-Learn para poder utilizar la función hacer_clasificación() que genera un conjunto de datos artificiales con los que se puede entrenar y probar el algoritmo.

A continuación, una clase Nodo definidos para representar los nodos del árbol de decisión. Cada nodo tiene varios atributos, como característica_idx, umbral, izquierda, derechay valor.

La clase Bosque aleatorio es la clase principal que implementa el algoritmo. Tiene varios parámetros como n_árboles, profundidad_máxima y min_samples_split. En ajustar()-función toma conjuntos de datos como entrada y genera árboles de decisión mediante selección aleatoria repetida para hacer una predicción.

La función construir_árbol() crea un árbol de decisión dividiendo recursivamente los datos. Si se alcanza la profundidad máxima, sólo hay una clase o no se alcanza el tamaño mínimo de la muestra, se crea un nodo hoja con la etiqueta más frecuente. En caso contrario, se selecciona una característica aleatoria, se calcula el mejor umbral para la división y los datos se dividen en consecuencia. A continuación, este proceso se aplica recursivamente a los dos subárboles hasta que se cumplen las condiciones de terminación.

En predecir()-genera predicciones para nuevos datos agregando las predicciones de todos los árboles de decisión. La función predecir_árbol()-La función toma una decisión basándose en los datos y en el árbol de decisión actual.

La función best_split() selecciona la mejor característica y el mejor umbral para la separación de un nodo de decisión calculando la ganancia de información. El sitio ganancia_de_información()-La función calcula la ganancia de información en función del valor umbral actual, mientras que la función entropía() calcula la entropía de un nodo. La dirección dividir()-La función divide los datos en dos subconjuntos, uno para cada rama del árbol de decisión. La función etiqueta_más_común() devuelve la etiqueta más frecuente.

En general, se trata de un ejemplo de código robusto que es una implementación clara del algoritmo Random Forest en Python. Utiliza varias técnicas como bootstrapping, muestreo de características y cálculos de entropía para realizar una predicción precisa.

Código de ejemplo Random Forest

He aquí un ejemplo de código para implementar un Random Forest en Python:

import numpy como np
from colecciones import Counter
from sklearn.datasets import make_classification
clase Nodo:
    def __init__(self, feature_idx=None, threshold=None, left=None, right=None, value=None):
        self.feature_idx = feature_idx
        self.umbral = umbral
        self.izquierda = izquierda
        self.right = right
        self.valor = valor
clase Bosquealeatorio:
    def __init__(self, n_trees=10, max_depth=5, min_samples_split=5):
        self.n_trees = n_trees
        self.max_depth = max_depth
        self.min_samples_split = min_samples_split
        self.árboles = []
    def fit(self, X, y):
        n_muestras, n_características = X.forma
        for i in range(self.n_árboles):
            muestra_idxs = np.random.choice(n_muestras, n_muestras, replace=True)
            X_bootstrap = X[sample_idxs]
            y_bootstrap = y[sample_idxs]
            tree = self.build_tree(X_bootstrap, y_bootstrap, 0)
            self.trees.append(árbol)
    def construir_árbol(self, X, y, profundidad):
        n_muestras, n_características = X.forma
        n_etiquetas = len(np.unique(y))
        if profundidad == self.max_profundidad o n_etiquetas == 1 o n_muestras < self.min_muestras_partir:
            valor_hoja = auto.etiqueta_más_común(y)
            return Nodo(valor=valor_hoja)
        feature_idxs = np.random.choice(n_características, int(np.sqrt(n_características)), replace=False)
        best_feature_idx, best_threshold = self.best_split(X, y, feature_idxs)
        left_idxs, right_idxs = self.split(X[:, best_feature_idx], best_threshold)
        left = self.build_tree(X[left_idxs, :], y[left_idxs], depth+1)
        right = self.build_tree(X[right_idxs, :], y[right_idxs], depth+1)
        return Nodo(mejor_característica_idx, mejor_umbral, izquierda, derecha)
    def predecir(self, X):
        predictions = np.zeros((X.shape[0], len(self.trees)))
        for i, tree in enumerate(self.trees):
            predicciones[:, i] = auto.predecir_árbol(X, árbol)
        return np.round(np.mean(predicciones, eje=1))
    def predecir_árbol(self, X, árbol):
        if árbol.valor no es None
            return árbol.valor
        si X[feature_idx.tree]  mejor_ganancia
                mejor_ganancia = ganancia
                split_idx = feature_idx
                split_umbral = umbral
    return dividir_idx, dividir_umbral
def ganancia_informacion(self, y, X_columna, split_umbral):
    parent_entropy = self.entropy(y)
    left_idxs, right_idxs = self.split(X_column, split_threshold)
    si len(left_idxs) == 0 o len(right_idxs) == 0:
        return 0
    n = len(y)
    n_l, n_r = len(izquierda_idxs), len(derecha_idxs)
    e_l, e_r = self.entropy(y[left_idxs]), self.entropy(y[right_idxs])
    entropía_hijo = (n_l/n)*e_l + (n_r/n)*e_r
    ig = entropía_padre - entropía_hijo
    return ig
def entropía(self, y):
    _, counts = np.unique(y, return_counts=True)
    probabilidades = recuentos / longitud(y)
    entropía = suma(probabilidades * -np.log2(probabilidades))
    return entropía
def split(self, X_columna, umbral):
    left_idxs = np.argwhere(X_columna  umbral).aplanar()
    return izquierda_idxs, derecha_idxs
def etiqueta_más_común(self, y):
    contador = contador(y)
    más_común = contador.más_común(1)
    return más_común[0][0]

Generar datos y ajustar el modelo RandomForest

X, y = make_classification(n_muestras=1000, n_características=10, n_informativas=5, random_state=42)
rf = RandomForest(n_árboles=10, max_profundidad=5, min_samples_split=5) rf.fit(X, y)

Predicciones

X_test = np.random.randn(10, 10)
predicciones = rf.predecir(X_prueba)

Esta es una implementación muy sencilla del algoritmo Random Forest en Python. Sin embargo, como se puede ver, es muy engorroso y hay que tener en cuenta muchas cosas. Por ejemplo, comprobar si se ha alcanzado la profundidad del árbol, el uso de árboles de decisión y el ajuste de las predicciones.

Por lo tanto, en la práctica, los paquetes se utilizan a menudo para implementar un Random Forest. A continuación encontrará cinco paquetes diferentes de Python que puede utilizar para implementar Random Forest.

Bosques aleatorios con Scikit-Learn

Scikit-Learn es un paquete popular en el mundo del aprendizaje automático y ofrece muchos algoritmos y funciones. Con Scikit-Learn puedes implementar bosques aleatorios con solo unas pocas líneas de código.

He aquí un ejemplo de código:

from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
# Crear datos y ajustar el modelo RandomForest
X, y = make_classification(n_muestras=1000, n_características=10, n_informativo=5, random_estado=42)
rf = RandomForestClassifier(n_estimadores=10, max_profundidad=5, min_samples_split=5, random_state=42)
rf.fit(X, y)
# Realizar predicciones
X_prueba = np.random.randn(10, 10)
predicciones = rf.predict(X_prueba)
print(predicciones)

Random Forest en XGBoost

XGBooses un paquete diseñado específicamente para su uso en árboles de decisión y algoritmos de refuerzo de gradiente.

. Es rápido y ofrece muchas opciones para personalizar los modelos. XGBoost también admite modelos Random Forest.

He aquí un ejemplo de código:

importar xgboost como xgb
from sklearn.datasets import make_classification
# Hacer datos
X, y = make_classification(n_muestras=1000, n_características=10, n_informativo=5, random_estado=42)
# Crear estructura de datos XGBoost
dtrain = xgb.DMatrix(X, label=y)
# Establecer hiperparámetros
params = {
    "objective": "multi:softprob",
    "eval_metric": "mlogloss",
    "num_class": len(np.unique(y)),
    "max_depth": 5,
    "submuestra": 0,8,
    "colsample_bytree": 0,8,
    "seed": 42
}
# Modelo de ajuste
num_round = 10
bst = xgb.train(params, dtrain, num_round)
# Realizar predicciones
X_test = np.random.randn(10, 10)
dtest = xgb.DMatrix(X_test)
predicciones = bst.predict(dtest)
print(predicciones)

Implementar árboles de decisión en LightGBM

LightGBM es otro paquete rápido para árboles de decisión y algoritmos de gradient boosting. También ofrece una opción para modelos de bosque aleatorio.

He aquí un ejemplo de código:

importar lightgbm como lgb
from sklearn.datasets import make_classification
# Hacer datos
X, y = make_classification(n_muestras=1000, n_características=10, n_informativo=5, random_estado=42)
# Crear estructura de datos LightGBM
lgb_train = lgb.Dataset(X, y)
# Establecer hiperparámetros
params = {
    "objetivo": "multiclase
    "num_class": len(np.unique(y)),
    "max_depth": 5,
    "submuestra": 0,8,
    "colsample_bytree": 0,8,
    "seed": 42
}
# Modelo de ajuste
num_round = 10
bst = lgb.train(parámetros, lgb_train, num_round)
# Realizar predicciones
X_prueba = np.random.randn(10, 10)
predicciones = bst.predecir(X_prueba)
print(predicciones)

RandomForestRegressor y RandomForestClassifier en Statsmodels

Statsmodels es un paquete especializado en la modelización y el análisis estadístico. También ofrece opciones para modelos de bosque aleatorio.

He aquí un ejemplo de código para RandomForestRegressor:

import statsmodels.api as sm
from sklearn.datasets import make_regression
# Generar datos
X, y = make_regression(n_muestras=100, n_características=10, random_state=42)
# Ajustar el modelo
rf = sm.OLS(y, X)
resultado = rf.fit()
# Realizar predicciones
X_test = np.random.randn(10, 10)
predicciones = resultado.predecir(X_prueba)
print(predicciones)

He aquí un ejemplo de código para RandomForestClassifier:

importar statsmodels.api como sm
from sklearn.datasets import make_classification
# Hacer datos
X, y = make_classification(n_muestras=100, n_características=10, random_state=42)
# Ajustar el modelo
rf = sm.discrete_model.RandomForest(y, X)
resultado = rf.fit()
# Realizar predicciones
X_test = np.random.randn(10, 10)
predicciones = resultado.predecir(X_prueba)
print(predicciones)

Conclusión

Random Forest es un popular Algoritmo en el mundo del aprendizaje automático y se utiliza a menudo para hacer predicciones. Existen muchos paquetes en Python que facilitan la implementación de modelos Random Forest, como Scikit-Learn, XGBoost, LightGBM y Statsmodels. Dependiendo de sus necesidades y de la cantidad de datos, puede elegir el paquete que más le convenga.

"
"
Avatar de Florian Zyprian

Últimos artículos