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 make_classification() que genera un conjunto de datos artificiales con los que se puede entrenar y probar el algoritmo.

A continuación, una clase Node definidos para representar los nodos del árbol de decisión. Cada nodo tiene varios atributos, como feature_idx, threshold, left, righty value.

La clase RandomForest es la clase principal que implementa el algoritmo. Tiene varios parámetros como n_trees, max_depth y min_samples_split. En fit()-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 build_tree() 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 predict()-genera predicciones para nuevos datos agregando las predicciones de todos los árboles de decisión. La función predict_tree()-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 information_gain()-La función calcula la ganancia de información en función del valor umbral actual, mientras que la función entropy() calcula la entropía de un nodo. La dirección split()-La función divide los datos en dos subconjuntos, uno para cada rama del árbol de decisión. La función most_common_label() 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 as np
from collections import Counter
from sklearn.datasets import make_classification
class Node:
    def __init__(self, feature_idx=None, threshold=None, left=None, right=None, value=None):
        self.feature_idx = feature_idx
        self.threshold = threshold
        self.left = left
        self.right = right
        self.value = value
class RandomForest:
    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.trees = []
    def fit(self, X, y):
        n_samples, n_features = X.shape
        for i in range(self.n_trees):
            sample_idxs = np.random.choice(n_samples, n_samples, replace=True)
            X_bootstrap = X[sample_idxs]
            y_bootstrap = y[sample_idxs]
            tree = self.build_tree(X_bootstrap, y_bootstrap, 0)
            self.trees.append(tree)
    def build_tree(self, X, y, depth):
        n_samples, n_features = X.shape
        n_labels = len(np.unique(y))
        if depth == self.max_depth or n_labels == 1 or n_samples < self.min_samples_split:
            leaf_value = self.most_common_label(y)
            return Node(value=leaf_value)
        feature_idxs = np.random.choice(n_features, int(np.sqrt(n_features)), 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 Node(best_feature_idx, best_threshold, left, right)
    def predict(self, X):
        predictions = np.zeros((X.shape[0], len(self.trees)))
        for i, tree in enumerate(self.trees):
            predictions[:, i] = self.predict_tree(X, tree)
        return np.round(np.mean(predictions, axis=1))
    def predict_tree(self, X, tree):
        if tree.value is not None:
            return tree.value
        if X[tree.feature_idx] <= tree.threshold:
            return self.predict_tree(X, tree.left)
        else:
            return self.predict_tree(X, tree.right)
    def best_split(self, X, y, feature_idxs):
        best_gain = -np.inf
        split_idx, split_threshold = None, None
        for feature_idx in feature_idxs:
            X_column = X[:, feature_idx]
        thresholds = np.unique(X_column)
        for threshold in thresholds:
            gain = self.information_gain(y, X_column, threshold)
            if gain > best_gain:
                best_gain = gain
                split_idx = feature_idx
                split_threshold = threshold
    return split_idx, split_threshold
def information_gain(self, y, X_column, split_threshold):
    parent_entropy = self.entropy(y)
    left_idxs, right_idxs = self.split(X_column, split_threshold)
    if len(left_idxs) == 0 or len(right_idxs) == 0:
        return 0
    n = len(y)
    n_l, n_r = len(left_idxs), len(right_idxs)
    e_l, e_r = self.entropy(y[left_idxs]), self.entropy(y[right_idxs])
    child_entropy = (n_l/n)*e_l + (n_r/n)*e_r
    ig = parent_entropy - child_entropy
    return ig
def entropy(self, y):
    _, counts = np.unique(y, return_counts=True)
    probabilities = counts / len(y)
    entropy = sum(probabilities * -np.log2(probabilities))
    return entropy
def split(self, X_column, threshold):
    left_idxs = np.argwhere(X_column <= threshold).flatten()
    right_idxs = np.argwhere(X_column > threshold).flatten()
    return left_idxs, right_idxs
def most_common_label(self, y):
    counter = Counter(y)
    most_common = counter.most_common(1)
    return most_common[0][0]

Generar datos y ajustar el modelo RandomForest

X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
rf = RandomForest(n_trees=10, max_depth=5, min_samples_split=5) rf.fit(X, y)

Predicciones

X_test = np.random.randn(10, 10)

predictions = rf.predict(X_test)

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
# Daten erzeugen und RandomForest-Modell anpassen
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
rf = RandomForestClassifier(n_estimators=10, max_depth=5, min_samples_split=5, random_state=42)
rf.fit(X, y)
# Vorhersagen machen
X_test = np.random.randn(10, 10)
predictions = rf.predict(X_test)
print(predictions)

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:

import xgboost as xgb
from sklearn.datasets import make_classification
# Daten erzeugen
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
# XGBoost-Daten-Struktur erstellen
dtrain = xgb.DMatrix(X, label=y)
# Hyperparameter einstellen
params = {
    "objective": "multi:softprob",
    "eval_metric": "mlogloss",
    "num_class": len(np.unique(y)),
    "max_depth": 5,
    "subsample": 0.8,
    "colsample_bytree": 0.8,
    "seed": 42
}
# Modell anpassen
num_round = 10
bst = xgb.train(params, dtrain, num_round)
# Vorhersagen machen
X_test = np.random.randn(10, 10)
dtest = xgb.DMatrix(X_test)
predictions = bst.predict(dtest)
print(predictions)

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:

import lightgbm as lgb
from sklearn.datasets import make_classification
# Daten erzeugen
X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, random_state=42)
# LightGBM-Daten-Struktur erstellen
lgb_train = lgb.Dataset(X, y)
# Hyperparameter einstellen
params = {
    "objective": "multiclass",
    "num_class": len(np.unique(y)),
    "max_depth": 5,
    "subsample": 0.8,
    "colsample_bytree": 0.8,
    "seed": 42
}
# Modell anpassen
num_round = 10
bst = lgb.train(params, lgb_train, num_round)
# Vorhersagen machen
X_test = np.random.randn(10, 10)
predictions = bst.predict(X_test)
print(predictions)

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
# Daten erzeugen
X, y = make_regression(n_samples=100, n_features=10, random_state=42)
# Modell anpassen
rf = sm.OLS(y, X)
result = rf.fit()
# Vorhersagen machen
X_test = np.random.randn(10, 10)
predictions = result.predict(X_test)
print(predictions)

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

import statsmodels.api as sm
from sklearn.datasets import make_classification
# Daten erzeugen
X, y = make_classification(n_samples=100, n_features=10, random_state=42)
# Modell anpassen
rf = sm.discrete_model.RandomForest(y, X)
result = rf.fit()
# Vorhersagen machen
X_test = np.random.randn(10, 10)
predictions = result.predict(X_test)
print(predictions)

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.