bagging is an ensemble learning technique that combines the predictions of multiple models to improve the accuracy and stability of a single model. it involves creating multiple subsets of the training data by randomly sampling with replacement. each subset is then used to train a separate model, and the final prediction is made by averaging the predictions of all models.

the main idea behind bagging is to reduce the variance of a single model by using multiple models that are less complex but still accurate. by averaging the predictions of multiple models, bagging reduces the risk of overfitting and improves the stability of the model.

how does bagging work?

the bagging algorithm works in the following steps −

create multiple subsets of the training data by randomly sampling with replacement.
train a separate model on each subset of the data.
make predictions on the testing data using each model.
combine the predictions of all models by taking the average or majority vote.

the key feature of bagging is that each model is trained on a different subset of the training data, which introduces diversity into the ensemble. the models are typically trained using a base model, such as a decision tree, logistic regression, or support vector machine.

example

now let's see how we can implement bagging in python using the scikit-learn library. for this example, we will use the famous iris dataset.

from sklearn.datasets import load_iris
from sklearn.ensemble import baggingclassifier
from sklearn.tree import decisiontreeclassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

# load the iris dataset
iris = load_iris()

# split the data into training and testing sets
x_train, x_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.2, random_state=42)

# define the base estimator
base_estimator = decisiontreeclassifier(max_depth=3)

# define the bagging classifier
bagging = baggingclassifier(base_estimator=base_estimator, n_estimators=10, random_state=42)

# train the bagging classifier
bagging.fit(x_train, y_train)

# make predictions on the testing set
y_pred = bagging.predict(x_test)

# evaluate the model's accuracy
accuracy = accuracy_score(y_test, y_pred)
print("accuracy:", accuracy)

in this example, we first load the iris dataset using scikit-learn's load_iris function and split it into training and testing sets using the train_test_split function.

we then define the base estimator, which is a decision tree with a maximum depth of 3, and the bagging classifier, which consists of 10 decision trees.

we train the bagging classifier using the fit method and make predictions on the testing set using the predict method. finally, we evaluate the model's accuracy using the accuracy_score function from scikit-learn's metrics module.

output

when you execute this code, it will produce the following output −

accuracy: 1.0

Save or share this article