Decision Tree In Machine Learning | Decision Tree Algorithm In Python

In the field of machine learning, decision trees are a powerful tool for classification and regression tasks. They are versatile, easy to interpret, and can handle both numerical and categorical data. In this article, we will explore the decision tree algorithm, how it works, and how to implement it in Python.

What is a Decision Tree?

A decision tree is a tree-like structure where each internal node represents a “test” or “decision” on an attribute (e.g., whether a customer is older than 50 years old) and each leaf node represents a class label (e.g., whether they will buy a product). The paths from the root to the leaf represent classification rules or decisions.

How Does a Decision Tree Work?

The decision tree algorithm works by recursively splitting the dataset into subsets based on the most significant attribute at each node. This splitting process continues until the data in each subset belongs to the same class, or some other stopping criteria are met.

Entropy and Information Gain

Entropy is a measure of impurity in a dataset. In the context of decision trees, it is used to determine the homogeneity of a dataset. Information gain is a metric used to decide which attribute to split on at each node. It measures the reduction in entropy after the dataset is split on a particular attribute.

Gini Impurity

Gini impurity is another measure of impurity commonly used in decision trees. It measures the probability of incorrectly classifying a randomly chosen element in the dataset if it were randomly labeled according to the distribution of labels in the subset.

Decision Tree Algorithm in Python

Now, let’s see how to implement a decision tree algorithm in Python using the popular machine learning library, scikit-learn.

First, we need to import the necessary libraries:

from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

Next, we load the Iris dataset and split it into training and testing sets:

iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(,, test_size=0.2, random_state=42)

Then, we initialize the decision tree classifier and fit it to the training data:

clf = DecisionTreeClassifier(random_state=42), y_train)

Finally, we make predictions on the test data and calculate the accuracy:

y_pred = clf.predict(X_test)
print("Accuracy:", accuracy_score(y_test, y_pred))

Handling Overfitting

One of the challenges with decision trees is overfitting, where the tree learns the training data too well and performs poorly on unseen data. To address this, we can use techniques like setting a maximum depth for the tree, setting a minimum number of samples required to split an internal node, or pruning the tree after it has been built.

Advantages of Decision Trees

  • Easy to interpret and visualize: Decision trees can be easily visualized and understood, making them suitable for both beginners and experts.
  • Handle both numerical and categorical data: Decision trees can handle both types of data, unlike some other algorithms that require data to be preprocessed.
  • Require little data preparation: Decision trees do not require data normalization, scaling, or transformation, which can save time and effort in data preprocessing.

Disadvantages of Decision Trees

  • Overfitting: As mentioned earlier, decision trees are prone to overfitting, especially when the tree depth is not limited.
  • Instability: Small variations in the data can result in a completely different tree being generated, leading to instability in the model.
  • Biased towards features with more levels: Decision trees tend to favor features with more levels because they can create more splits and therefore better fit the training data.


In this article, we have discussed the decision tree algorithm in machine learning, how it works, and how to implement it in Python using the scikit-learn library. Decision trees are powerful and easy-to-understand models that are widely used in various applications.

Post Views: 0

Scroll to Top