Balancing the Scale: A Comprehensive Approach to Imbalanced Datasets in Python

Imbalanced datasets are those in which the number of samples belonging to one class is significantly larger than the number of samples belonging to the other class(es). This can be a problem when building machine learning models, as the model is more likely to predict the class with more samples, leading to poor performance on the minority class.

In this tutorial, we will learn how to deal with imbalanced datasets in the context of machine learning.

1. Identifying imbalanced datasets

The first step in dealing with imbalanced datasets is to identify whether our dataset is imbalanced or not. One way to do this is to check the class distribution of the target variable.

For example, let’s say we have a dataset with a binary target variable, y, which can be either 0 or 1. We can check the class distribution using the value_counts method of the Pandas DataFrame:

1
import pandas as pd
2

3
df = pd.read_csv('my_dataset.csv')
4
print(df['y'].value_counts())

If the ratio of samples belonging to class 0 to samples belonging to class 1 is significantly large (e.g., 9), then we can consider our dataset to be imbalanced.

2. Balancing the dataset

Once we have identified that our dataset is imbalanced, we can try to balance it in order to improve the performance of our machine learning model. Here are some ways to balance an imbalanced dataset:

2.1. Undersampling

Undersampling involves reducing the number of samples in the majority class to be equal to the number of samples in the minority class. This can be done by randomly selecting a subset of the majority class samples.

1
# Separate majority and minority classes
2
df_majority = df[df['y']==0]
3
df_minority = df[df['y']==1]
4

5
# Downsample majority class
6
df_majority_downsampled = df_majority.sample(n=len(df_minority), random_state=123)
7

8
# Combine minority class with downsampled majority class
9
df_downsampled = pd.concat([df_majority_downsampled, df_minority])

2.2. Oversampling

Oversampling involves generating new samples in the minority class, using techniques such as bootstrapping or SMOTE (Synthetic Minority Oversampling TEchnique).

For example, to use SMOTE for oversampling, we can use the SMOTE function from the imblearn library:

1
from imblearn.over_sampling import SMOTE
2

3
smote = SMOTE(random_state=123)
4
X_sm, y_sm = smote.fit_sample(X, y)

2.3. Combining undersampling and oversampling

Another option is to combine both undersampling and oversampling, using techniques such as SMOTE-ENN (SMOTE + Edited Nearest Neighbors) or SMOTE-Tomek.

1
from imblearn.combine import SMOTEENN
2

3
smote_enn = SMOTEENN(random_state=123)
4
X_smote_enn, y_smote_enn = smote_enn.fit_sample(X, y)

3. Evaluating the performance of the model

Once we have balanced our dataset, we can use it to train a machine learning model and evaluate its performance. It is important to compare the performance of the model on the balanced dataset with the performance of the model on the original imbalanced dataset, to see if balancing the dataset has improved the model’s performance.

For example, we can train a random forest classifier on the balanced dataset and evaluate its performance using metrics such as accuracy, precision, and recall:

1
from sklearn.ensemble import RandomForestClassifier
2
from sklearn.metrics import accuracy_score, precision_score, recall_score
3

4
# Train the model
5
model = RandomForestClassifier(random_state=123)
6
model.fit(X_smote_enn, y_smote_enn)
7

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

11
# Evaluate the model
12
accuracy = accuracy_score(y_test, y_pred)
13
precision = precision_score(y_test, y_pred)
14
recall = recall_score(y_test, y_pred)
15

16
print(f'Accuracy: {accuracy:.3f}')
17
print(f'Precision: {precision:.3f}')
18
print(f'Recall: {recall:.3f}')

4. Wrapping it up

In this tutorial, we learned how to deal with imbalanced datasets in the context of machine learning. We saw three different approaches to balancing the dataset: undersampling, oversampling, and combining undersampling and oversampling. By balancing the dataset, we can improve the performance of our machine learning model and get better results on the minority class.