Decision Trees: Basics and Implementation

Decision Trees are a popular machine learning algorithm used for both classification and regression tasks. They work by recursively partitioning the data into subsets based on the values of input features, leading to a tree-like structure where each internal node represents a decision based on a feature, each branch represents an outcome of that decision, and each leaf node represents the final predicted outcome.

Key Concepts:

  1. Decision Node:
  • Internal nodes in the tree where a decision is made based on the value of a particular feature.
  1. Branch:
  • The path followed based on the outcome of a decision at a decision node.
  1. Leaf Node:
  • Terminal nodes where the final prediction or outcome is made.
  1. Criterion (Gini, Entropy, MSE):
  • The metric used to measure the impurity or homogeneity of a set of data. Common criteria include Gini impurity, entropy, and mean squared error.
  1. Splitting:
  • The process of dividing a set of data into subsets based on a chosen criterion and a selected feature.
  1. Pruning:
  • The process of removing branches or nodes from the tree to prevent overfitting and improve generalization to new data.

Classification Decision Tree Example:

Consider a simple example where we want to predict whether a person will play tennis based on weather conditions (Outlook, Temperature, Humidity, Wind). The decision tree might look like this:

Decision Node: Outlook
|--- Sunny
|    |--- Humidity <= 75: Play Tennis (Yes)
|    |--- Humidity > 75: Don't Play Tennis (No)
|--- Overcast: Play Tennis (Yes)
|--- Rainy
     |--- Wind = Weak: Play Tennis (Yes)
     |--- Wind = Strong: Don't Play Tennis (No)

Implementation in Python:

Using the scikit-learn library for decision trees:

# Import necessary libraries
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import pandas as pd

# Assume df is your DataFrame with features (X) and target variable (y)
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(df.drop('target', axis=1), df['target'], test_size=0.2, random_state=42)

# Initialize the decision tree classifier
model = DecisionTreeClassifier()

# Train the model on the training set
model.fit(X_train, y_train)

# Make predictions on the test set
y_pred = model.predict(X_test)

# Evaluate the model performance
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
classification_report_str = classification_report(y_test, y_pred)

# Print the results
print("Accuracy:", accuracy)
print("Confusion Matrix:\n", conf_matrix)
print("Classification Report:\n", classification_report_str)

Interpretation of Results:

  • Accuracy: The proportion of correctly classified instances.
  • Confusion Matrix: A table showing the number of true positives, true negatives, false positives, and false negatives.
  • Classification Report: Provides precision, recall, F1-score, and support for each class.


  • Tree Depth: Control the depth of the tree to avoid overfitting. This can be adjusted using the max_depth hyperparameter.
  • Criterion: Experiment with different impurity criteria (Gini impurity, entropy) to find the most suitable for your problem.
  • Visualizing the Tree: You can visualize the decision tree using libraries like graphviz or plotly.
  • Feature Importance: Decision trees provide feature importances, indicating the contribution of each feature to the model.

Decision Trees are versatile and easy to interpret. However, they can be prone to overfitting, and the interpretability might decrease as the tree becomes deeper. Techniques like pruning and limiting the tree depth can address these issues and improve generalization.