SMOTE in Machine Learning Explained with Python Examples

Imbalanced datasets are one of the most common challenges in machine learning. When one class significantly outnumbers another, models often become biased, leading to poor predictive performance. To solve this, SMOTE (Synthetic Minority Over-sampling Technique) is widely used.

So, what exactly is SMOTE in Machine Learning? How does it work, and when should you use it? Let’s dive in.

What is SMOTE in Machine Learning?

SMOTE (Synthetic Minority Over-sampling Technique) is a data preprocessing technique introduced in 2002. Instead of simply duplicating minority class samples, SMOTE creates synthetic examples by interpolating between existing minority samples.

This approach helps the model:

• • Avoid bias toward majority classes
  • Improve classification performance
  • Work better in imbalanced datasets

How Does SMOTE Work?

1. For each minority class sample, SMOTE selects k nearest neighbors (default = 5).
2. It randomly chooses one neighbor.
3. It creates a synthetic sample along the line segment between the data point and its neighbor.

Example: If we have only 50 fraud transactions vs. 5000 non-fraud, SMOTE generates synthetic fraud transactions to balance the dataset.

Python Example: Applying SMOTE

Here’s how you can use SMOTE with scikit-learn and imbalanced-learn:

from sklearn.datasets import make_classification
from imblearn.over_sampling import SMOTE
from collections import Counter

# Create an imbalanced dataset
X, y = make_classification(n_samples=1000, n_features=10, 
                           n_classes=2, weights=[0.9, 0.1], 
                           random_state=42)

print("Original dataset shape:", Counter(y))

# Apply SMOTE
smote = SMOTE(random_state=42)
X_res, y_res = smote.fit_resample(X, y)

print("Resampled dataset shape:", Counter(y_res))

Output:

Original dataset shape: Counter({0: 900, 1: 100})  
Resampled dataset shape: Counter({0: 900, 1: 900})

Here, SMOTE balances the dataset by generating synthetic minority class samples.

Variants of SMOTE

SMOTE has several extensions to handle different situations:

• Borderline-SMOTE: Focuses on samples near decision boundaries.
• SMOTEENN: Combines SMOTE with Edited Nearest Neighbors to remove noisy samples.
• ADASYN (Adaptive Synthetic Sampling): Generates more synthetic samples for harder-to-learn cases.

Python Example: Borderline-SMOTE

from imblearn.over_sampling import BorderlineSMOTE

borderline = BorderlineSMOTE(random_state=42)
X_res, y_res = borderline.fit_resample(X, y)
print("Resampled dataset shape (Borderline-SMOTE):", Counter(y_res))

When to Use SMOTE

• Binary classification with class imbalance (fraud detection, spam filtering, medical diagnosis)
• When minority class is underrepresented (10:1, 20:1 ratios or worse)
• Before training classifiers like Logistic Regression, Decision Trees, or Random Forests

When not to use:

• When the dataset is very small → SMOTE might overfit.
• When a minority class has significant noise → SMOTE will amplify it.

Pros and Cons of SMOTE

Pros

• Balances datasets effectively
• Improves recall and F1 score
• Works well with many ML algorithms

Cons

• May introduce overfitting
• Synthetic samples may not represent real-world cases
• Increases computational cost

Conclusion

SMOTE in machine learning is a powerful technique to handle imbalanced datasets by generating synthetic samples of minority classes. It outperforms simple oversampling, improves classification results, and is widely used in real-world applications like fraud detection, medical imaging, and anomaly detection.

By combining SMOTE with modern classifiers, data scientists can build fairer, more accurate ML models that capture minority class patterns effectively.