Random Forest es un popular algoritmo de aprendizaje automático que pertenece a la técnica de aprendizaje supervisado. Se puede utilizar tanto para problemas de clasificación como de regresión en ML. Se basa en el concepto de aprendizaje en conjunto, que es un proceso de combinar múltiples clasificadores para resolver un problema complejo y mejorar el rendimiento del modelo.
Como el nombre sugiere, 'Random Forest es un clasificador que contiene varios árboles de decisión en varios subconjuntos del conjunto de datos dado y toma el promedio para mejorar la precisión predictiva de ese conjunto de datos'. En lugar de depender de un árbol de decisión, el bosque aleatorio toma la predicción de cada árbol y, basándose en los votos mayoritarios de las predicciones, predice el resultado final.
Un mayor número de árboles en el bosque conduce a una mayor precisión y evita el problema del sobreajuste.
matemáticas pow java
El siguiente diagrama explica el funcionamiento del algoritmo Random Forest:
Nota: Para comprender mejor el algoritmo de bosque aleatorio, debe tener conocimientos del algoritmo de árbol de decisión.
Supuestos para el bosque aleatorio
Dado que el bosque aleatorio combina varios árboles para predecir la clase del conjunto de datos, es posible que algunos árboles de decisión predigan el resultado correcto, mientras que otros no. Pero juntos, todos los árboles predicen el resultado correcto. Por lo tanto, a continuación se presentan dos supuestos para un mejor clasificador de bosque aleatorio:
- Debe haber algunos valores reales en la variable característica del conjunto de datos para que el clasificador pueda predecir resultados precisos en lugar de un resultado adivinado.
- Las predicciones de cada árbol deben tener correlaciones muy bajas.
¿Por qué utilizar el bosque aleatorio?
A continuación se muestran algunos puntos que explican por qué deberíamos utilizar el algoritmo Random Forest:
- Requiere menos tiempo de entrenamiento en comparación con otros algoritmos.
- Predice la salida con alta precisión, incluso para el gran conjunto de datos que ejecuta de manera eficiente.
- También puede mantener la precisión cuando falta una gran proporción de datos.
¿Cómo funciona el algoritmo Random Forest?
Random Forest funciona en dos fases: la primera es crear el bosque aleatorio combinando N árboles de decisión y la segunda es hacer predicciones para cada árbol creado en la primera fase.
El proceso de trabajo se puede explicar en los siguientes pasos y diagrama:
Paso 1: Seleccione K puntos de datos aleatorios del conjunto de entrenamiento.
Paso 2: Construya los árboles de decisión asociados con los puntos de datos seleccionados (Subconjuntos).
Paso 3: Elija el número N para los árboles de decisión que desea crear.
Etapa 4: Repita los pasos 1 y 2.
listar java a matriz
Paso 5: Para nuevos puntos de datos, busque las predicciones de cada árbol de decisión y asigne los nuevos puntos de datos a la categoría que gane la mayoría de votos.
El funcionamiento del algoritmo se puede entender mejor con el siguiente ejemplo:
Ejemplo: Supongamos que hay un conjunto de datos que contiene varias imágenes de frutas. Entonces, este conjunto de datos se entrega al clasificador de bosque aleatorio. El conjunto de datos se divide en subconjuntos y se asigna a cada árbol de decisión. Durante la fase de entrenamiento, cada árbol de decisión produce un resultado de predicción, y cuando ocurre un nuevo punto de datos, basándose en la mayoría de los resultados, el clasificador de Random Forest predice la decisión final. Considere la siguiente imagen:
Aplicaciones del bosque aleatorio
Hay principalmente cuatro sectores donde se utiliza principalmente el bosque aleatorio:
Ventajas del bosque aleatorio
- Random Forest es capaz de realizar tareas de clasificación y regresión.
- Es capaz de manejar grandes conjuntos de datos con alta dimensionalidad.
- Mejora la precisión del modelo y evita el problema de sobreajuste.
Desventajas del bosque aleatorio
- Aunque el bosque aleatorio se puede utilizar tanto para tareas de clasificación como de regresión, no es más adecuado para tareas de regresión.
Implementación en Python del algoritmo de bosque aleatorio
Ahora implementaremos el árbol del algoritmo de bosque aleatorio usando Python. Para ello, utilizaremos el mismo conjunto de datos 'user_data.csv', que hemos utilizado en modelos de clasificación anteriores. Al utilizar el mismo conjunto de datos, podemos comparar el clasificador Random Forest con otros modelos de clasificación como Clasificador de árbol de decisión, knn, SVM, regresión logística, etc.
Los pasos de implementación se detallan a continuación:
- Paso de preprocesamiento de datos
- Ajustar el algoritmo de bosque aleatorio al conjunto de entrenamiento
- Predecir el resultado de la prueba
- Pruebe la precisión del resultado (Creación de matriz de confusión)
- Visualizando el resultado del conjunto de pruebas.
1.Paso de preprocesamiento de datos:
A continuación se muestra el código para el paso de preprocesamiento:
base de datos java jdbc
# importing libraries import numpy as nm import matplotlib.pyplot as mtp import pandas as pd #importing datasets data_set= pd.read_csv('user_data.csv') #Extracting Independent and dependent Variable x= data_set.iloc[:, [2,3]].values y= data_set.iloc[:, 4].values # Splitting the dataset into training and test set. from sklearn.model_selection import train_test_split x_train, x_test, y_train, y_test= train_test_split(x, y, test_size= 0.25, random_state=0) #feature Scaling from sklearn.preprocessing import StandardScaler st_x= StandardScaler() x_train= st_x.fit_transform(x_train) x_test= st_x.transform(x_test)
En el código anterior, hemos preprocesado los datos. Donde hemos cargado el conjunto de datos, que se expresa como:
2. Ajustar el algoritmo Random Forest al conjunto de entrenamiento:
Ahora ajustaremos el algoritmo de bosque aleatorio al conjunto de entrenamiento. Para ajustarlo, importaremos el Clasificador de bosque aleatorio clase de la sklearn.ensemble biblioteca. El código se proporciona a continuación:
#Fitting Decision Tree classifier to the training set from sklearn.ensemble import RandomForestClassifier classifier= RandomForestClassifier(n_estimators= 10, criterion='entropy') classifier.fit(x_train, y_train)
En el código anterior, el objeto clasificador toma los siguientes parámetros:
Producción:
RandomForestClassifier(bootstrap=True, class_weight=None, criterion='entropy', max_depth=None, max_features='auto', max_leaf_nodes=None, min_impurity_decrease=0.0, min_impurity_split=None, min_samples_leaf=1, min_samples_split=2, min_weight_fraction_leaf=0.0, n_estimators=10, n_jobs=None, oob_score=False, random_state=None, verbose=0, warm_start=False)
3. Predicción del resultado del conjunto de pruebas
Dado que nuestro modelo está ajustado al conjunto de entrenamiento, ahora podemos predecir el resultado de la prueba. Para la predicción, crearemos un nuevo vector de predicción y_pred. A continuación se muestra el código para ello:
#Predicting the test set result y_pred= classifier.predict(x_test)
Producción:
El vector de predicción viene dado por:
Al verificar el vector de predicción anterior y el vector real del conjunto de prueba, podemos determinar las predicciones incorrectas realizadas por el clasificador.
cuando salio win 7
4. Creando la matriz de confusión
Ahora crearemos la matriz de confusión para determinar las predicciones correctas e incorrectas. A continuación se muestra el código para ello:
#Creating the Confusion matrix from sklearn.metrics import confusion_matrix cm= confusion_matrix(y_test, y_pred)
Producción:
Como podemos ver en la matriz anterior, existen 4+4= 8 predicciones incorrectas y 64+28= 92 predicciones correctas.
5. Visualización del resultado del conjunto de entrenamiento
Aquí visualizaremos el resultado del conjunto de entrenamiento. Para visualizar el resultado del conjunto de entrenamiento, trazaremos un gráfico para el clasificador de bosque aleatorio. El clasificador predecirá sí o no para los usuarios que compraron o no el automóvil SUV como lo hicimos en Regresión logística. A continuación se muestra el código para ello:
from matplotlib.colors import ListedColormap x_set, y_set = x_train, y_train x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm (Training set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Producción:
La imagen de arriba es el resultado de la visualización del clasificador Random Forest que trabaja con el resultado del conjunto de entrenamiento. Es muy similar al clasificador de árbol de decisión. Cada punto de datos corresponde a cada usuario de user_data, y las regiones violeta y verde son las regiones de predicción. La región violeta está clasificada para los usuarios que no compraron el automóvil SUV y la región verde es para los usuarios que compraron el SUV.
convertir un número entero en una cadena
Entonces, en el clasificador de Bosque Aleatorio, hemos tomado 10 árboles que han predicho Sí o NO para la variable Comprado. El clasificador tomó la mayoría de las predicciones y proporcionó el resultado.
6. Visualización del resultado del conjunto de pruebas
Ahora visualizaremos el resultado del conjunto de pruebas. A continuación se muestra el código para ello:
#Visulaizing the test set result from matplotlib.colors import ListedColormap x_set, y_set = x_test, y_test x1, x2 = nm.meshgrid(nm.arange(start = x_set[:, 0].min() - 1, stop = x_set[:, 0].max() + 1, step =0.01), nm.arange(start = x_set[:, 1].min() - 1, stop = x_set[:, 1].max() + 1, step = 0.01)) mtp.contourf(x1, x2, classifier.predict(nm.array([x1.ravel(), x2.ravel()]).T).reshape(x1.shape), alpha = 0.75, cmap = ListedColormap(('purple','green' ))) mtp.xlim(x1.min(), x1.max()) mtp.ylim(x2.min(), x2.max()) for i, j in enumerate(nm.unique(y_set)): mtp.scatter(x_set[y_set == j, 0], x_set[y_set == j, 1], c = ListedColormap(('purple', 'green'))(i), label = j) mtp.title('Random Forest Algorithm(Test set)') mtp.xlabel('Age') mtp.ylabel('Estimated Salary') mtp.legend() mtp.show()
Producción:
La imagen de arriba es el resultado de la visualización del conjunto de prueba. Podemos comprobar que hay un número mínimo de predicciones incorrectas (8) sin el problema de Overfitting. Obtendremos resultados diferentes cambiando la cantidad de árboles en el clasificador.