random forest is a machine learning algorithm that uses an ensemble of decision trees to make predictions. the algorithm was first introduced by leo breiman in 2001. the key idea behind the algorithm is to create a large number of decision trees, each of which is trained on a different subset of the data. the predictions of these individual trees are then combined to produce a final prediction.

working of random forest algorithm

we can understand the working of random forest algorithm with the help of following steps −

step 1 − first, start with the selection of random samples from a given dataset.
step 2 − next, this algorithm will construct a decision tree for every sample. then it will get the prediction result from every decision tree.
step 3 − in this step, voting will be performed for every predicted result.
step 4 − at last, select the most voted prediction result as the final prediction result.

the following diagram illustrates how the random forest algorithm works −

random forest is a flexible algorithm that can be used for both classification and regression tasks. in classification tasks, the algorithm uses the mode of the predictions of the individual trees to make the final prediction. in regression tasks, the algorithm uses the mean of the predictions of the individual trees.

advantages of random forest algorithm

random forest algorithm has several advantages over other machine learning algorithms. some of the key advantages are −

robustness to overfitting − random forest algorithm is known for its robustness to overfitting. this is because the algorithm uses an ensemble of decision trees, which helps to reduce the impact of outliers and noise in the data.
high accuracy − random forest algorithm is known for its high accuracy. this is because the algorithm combines the predictions of multiple decision trees, which helps to reduce the impact of individual decision trees that may be biased or inaccurate.
handles missing data − random forest algorithm can handle missing data without the need for imputation. this is because the algorithm only considers the features that are available for each data point and does not require all features to be present for all data points.
non-linear relationships − random forest algorithm can handle non-linear relationships between the features and the target variable. this is because the algorithm uses decision trees, which can model non-linear relationships.
feature importance − random forest algorithm can provide information about the importance of each feature in the model. this information can be used to identify the most important features in the data and can be used for feature selection and feature engineering.

implementation of random forest algorithm in python

let's take a look at the implementation of random forest algorithm in python. we will be using the scikit-learn library to implement the algorithm. the scikit-learn library is a popular machine learning library that provides a wide range of algorithms and tools for machine learning.

step 1 − importing the libraries

we will begin by importing the necessary libraries. we will be using the pandas library for data manipulation, and the scikit-learn library for implementing the random forest algorithm.

import pandas as pd
from sklearn.ensemble import randomforestclassifier

step 2 − loading the data

next, we will load the data into a pandas dataframe. for this tutorial, we will be using the famous iris dataset, which is a classic dataset for classification tasks.

# loading the iris dataset

iris = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learningdatabases/iris/iris.data', header=none)

iris.columns = ['sepal_length', 'sepal_width', 'petal_length','petal_width', 'species']

step 3 − data preprocessing

before we can use the data to train our model, we need to preprocess it. this involves separating the features and the target variable and splitting the data into training and testing sets.

# separating the features and target variable
x = iris.iloc[:, :-1]
y = iris.iloc[:, -1]

# splitting the data into training and testing sets
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.35, random_state=42)

step 4 − training the model

next, we will train our random forest classifier on the training data.

# creating the random forest classifier object
rfc = randomforestclassifier(n_estimators=100)

# training the model on the training data
rfc.fit(x_train, y_train)

step 5 − making predictions

once we have trained our model, we can use it to make predictions on the test data.

# making predictions on the test data
y_pred = rfc.predict(x_test)

step 6 − evaluating the model

finally, we will evaluate the performance of our model using various metrics such as accuracy, precision, recall, and f1-score.

# importing the metrics library
from sklearn.metrics import accuracy_score, precision_score,
recall_score, f1_score

# calculating the accuracy, precision, recall, and f1-score
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')

print("accuracy:", accuracy)
print("precision:", precision)
print("recall:", recall)
print("f1-score:", f1)

complete implementation example

below is the complete implementation example of random forest algorithm in python using the iris dataset −

import pandas as pd
from sklearn.ensemble import randomforestclassifier

# loading the iris dataset
iris = pd.read_csv('https://archive.ics.uci.edu/ml/machine-learningdatabases/iris/iris.data', header=none)

iris.columns = ['sepal_length', 'sepal_width', 'petal_length', 'petal_width', 'species']

# separating the features and target variable
x = iris.iloc[:, :-1]
y = iris.iloc[:, -1]

# splitting the data into training and testing sets
from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x, y,
test_size=0.35, random_state=42)

# creating the random forest classifier object
rfc = randomforestclassifier(n_estimators=100)

# training the model on the training data
rfc.fit(x_train, y_train)
# making predictions on the test data
y_pred = rfc.predict(x_test)
# importing the metrics library
from sklearn.metrics import accuracy_score, precision_score,
recall_score, f1_score

# calculating the accuracy, precision, recall, and f1-score
accuracy = accuracy_score(y_test, y_pred)
precision = precision_score(y_test, y_pred, average='weighted')
recall = recall_score(y_test, y_pred, average='weighted')
f1 = f1_score(y_test, y_pred, average='weighted')

print("accuracy:", accuracy)
print("precision:", precision)
print("recall:", recall)
print("f1-score:", f1)

output

this will give us the performance metrics of our random forest classifier as follows −

accuracy: 0.9811320754716981
precision: 0.9821802935010483
recall: 0.9811320754716981
f1-score: 0.9811157396063056

pros and cons of random forest

pros

the following are the advantages of random forest algorithm −

it overcomes the problem of overfitting by averaging or combining the results of different decision trees.
random forests work well for a large range of data items than a single decision tree does.
random forest has less variance then single decision tree.
random forests are very flexible and possess very high accuracy.
scaling of data does not require in random forest algorithm. it maintains good accuracy even after providing data without scaling.
scaling of data does not require in random forest algorithm. it maintains good accuracy even after providing data without scaling.

cons

the following are the disadvantages of random forest algorithm −

complexity is the main disadvantage of random forest algorithms.
construction of random forests are much harder and time-consuming than decision trees.
more computational resources are required to implement random forest algorithm.
it is less intuitive in case when we have a large collection of decision trees .
the prediction process using random forests is very time-consuming in comparison with other algorithms.

Save or share this article