What Is SMOTE (Synthetic Minority Over-sampling Technique)?
- 23 hours ago
- 26 min read
A hospital builds a model to flag patients at risk of sepsis. The model reports 98% accuracy in testing, and the team celebrates — until someone notices it flags almost no actual sepsis cases at all. It just learned to say "no risk" for nearly everyone, because non-sepsis patients made up 98% of the training data. The same story repeats in credit-card fraud detection, industrial equipment failure prediction, and customer-churn forecasting: the event that matters most is also the one a classifier sees least. This is the class-imbalance problem, and it is the reason a technique called SMOTE — the Synthetic Minority Over-sampling Technique — has become one of the most widely used tools in machine learning for classification tasks.
TL;DR
SMOTE is a training-data resampling method that generates new, synthetic minority-class examples instead of duplicating existing rows.
It works by interpolating between a real minority observation and one of its nearest minority neighbors in feature space.
Practitioners use it to give a classifier more minority-region examples to learn from, especially when the minority class is rare but important.
Its biggest limitation is that interpolation can create unrealistic or noisy points when classes overlap, neighbors are outliers, or categorical data is treated as numeric.
SMOTE must be fit only on the training partition or training fold — never on validation or test data — or evaluation results become inflated and misleading.
Because SMOTE changes the training distribution, accuracy alone is not a trustworthy metric afterward; recall, precision, F1, balanced accuracy, and ROC-AUC or precision-recall curves matter far more.
What Is SMOTE (Synthetic Minority Over-sampling Technique)?
SMOTE (Synthetic Minority Over-sampling Technique) is a resampling method for imbalanced classification. It creates new synthetic minority-class examples by interpolating between a real minority observation and one of its nearest minority-class neighbors in feature space, rather than duplicating existing rows. SMOTE is applied only to training data, never to validation or test data.
Table of Contents
The Class-Imbalance Problem
Class imbalance means one class in a labeled dataset has far more examples than another. The larger group is the majority class; the rarer, usually more important, group is the minority class. Imbalance can be mild (60/40) or extreme (99.9/0.1), and it appears in both binary problems (fraud vs. not-fraud) and multiclass problems (rare disease subtypes among common diagnoses).
Imbalance ratio alone does not tell you how severe a problem is. What actually determines severity is (1) how much overlap exists between classes in feature space, and (2) how costly it is to miss a minority case. A 1,000:1 imbalance with clearly separable classes may be easy; a 3:1 imbalance with heavily overlapping classes can be much harder.
Real-world imbalanced problems include credit-card fraud detection, rare-disease screening, industrial-equipment failure prediction, customer-churn modeling, and AI-driven cybersecurity threat detection, where malicious events are a tiny fraction of total network traffic.
Numerical example. Suppose a dataset has 10,000 transactions, of which 9,900 are legitimate and 100 are fraudulent (a 99%/1% split). A classifier that predicts "legitimate" for every single transaction achieves 99% accuracy — yet it catches zero fraud cases. Its recall for the minority class is 0%. This is why AI accuracy rate figures, taken alone, can be dangerously misleading on imbalanced data; a model can look excellent on paper while being operationally useless.
A Clear Definition of SMOTE
SMOTE stands for Synthetic Minority Over-sampling Technique. It was introduced by Nitesh V. Chawla, Kevin W. Bowyer, Lawrence O. Hall, and W. Philip Kegelmeyer in a 2002 paper published in the Journal of Artificial Intelligence Research [1]. SMOTE is an oversampling method: it increases the number of minority-class examples in the training data. Crucially, it does this by generating new synthetic feature vectors, not by copying existing rows.
SMOTE operates entirely in feature space — the multi-dimensional space defined by a dataset's input variables. It changes the training distribution the model learns from; it does not change the real-world population the data was drawn from. SMOTE is associated almost exclusively with supervised classification problems, where labeled minority and majority examples already exist. This distinguishes it from broader "synthetic data generation" methods (such as generative models), which can create entirely new records without needing nearby real examples to interpolate from.
It helps to separate three concepts clearly:
Type | What it is | Risk |
Real observation | An actual recorded event | None — but may be scarce |
Duplicated observation | An exact copy of a real row | Can cause overfitting to specific points |
Interpolated synthetic observation (SMOTE) | A new point between two real neighbors | Can be unrealistic if neighbors are poorly chosen |
The Intuition Behind SMOTE
Picture two minority-class fraud transactions plotted by two features: transaction amount and account age (in days). Transaction A sits at (200, 30) and Transaction B, one of its nearest minority neighbors, sits at (240, 50). SMOTE does not simply average these two points — it picks a random location somewhere on the line segment connecting them, using a random fraction between 0 and 1.
Account age (days)
60 | B (240, 50)
50 | * <- possible synthetic point
40 | *
30 | A (200, 30)
+------------------------------
190 210 230 250 Amount ($)The reasoning is geometric: if two minority points are close together and both represent genuine minority behavior, the space between them is a plausible region for more minority behavior to exist. Adding examples there gives a classifier more resolution in a region it previously had to guess about, which can sharpen the decision boundary between classes.
This intuition breaks down in several realistic situations:
Separate subclusters — if "A" and "B" belong to two different minority subgroups (say, two unrelated fraud schemes), the line between them can cross a region that isn't fraud-like at all.
Outliers — if the chosen neighbor is itself a mislabeled or freak observation, SMOTE will faithfully reproduce that mistake in synthetic form.
Overlapping classes — when majority and minority points sit close together, interpolated points can land inside majority territory.
Poorly defined distance — Euclidean distance assumes features are comparable; if they aren't scaled, "nearest" neighbors may not be meaningfully similar.
Categorical variables treated as numbers — interpolating between category codes 1 and 3 to get 2 can produce a category that doesn't exist.
How the SMOTE Algorithm Works Step by Step
Identify the class to oversample (usually the minority class, or classes, in a classification problem).
Select a minority-class observation, denoted x_i.
Find its k nearest minority-class neighbors in feature space (k is a tunable parameter, default 5 in most libraries [2]).
Choose one neighbor at random, denoted x_neighbor.
Draw a random interpolation coefficient λ, typically sampled uniformly from [0, 1].
Create a synthetic observation using:
x_new = x_i + λ(x_neighbor − x_i)
Where:
x_i = the selected real minority observation (a feature vector)
x_neighbor = one of its k nearest minority neighbors
λ (lambda) = a random number between 0 and 1 controlling how far along the line segment the new point sits
x_new = the resulting synthetic minority observation
Repeat this process, selecting new base points and neighbors, until the requested number of synthetic examples has been generated.
k_neighbors controls how large the neighborhood is when searching for a partner point; a small value keeps synthesis very local, while a larger value pulls from a wider, potentially less-similar neighborhood. If the minority class has fewer observations than k_neighbors + 1, most implementations will raise an error or automatically reduce the neighbor count — this is a common failure point when the minority class is very small. Not every library implements identical internal sampling logic (some, for example, iterate deterministically over minority points rather than sampling them at random), so the conceptual algorithm above should be treated as the shared core, not a guarantee of byte-for-byte identical behavior across tools.
A Fully Worked Numerical Example
Suppose two minority-class observations, each with two numeric features (feature 1, feature 2):
x_i = (2.0, 4.0)
x_neighbor = (6.0, 8.0)
Choose λ = 0.25 (a specific, arbitrary draw from [0, 1]).
Step 1 — Subtract: x_neighbor − x_i = (6.0 − 2.0, 8.0 − 4.0) = (4.0, 4.0)
Step 2 — Multiply by λ: λ(x_neighbor − x_i) = 0.25 × (4.0, 4.0) = (1.0, 1.0)
Step 3 — Add to x_i: x_new = (2.0, 4.0) + (1.0, 1.0) = (3.0, 5.0)
The synthetic point is (3.0, 5.0) — exactly one-quarter of the way from x_i toward x_neighbor. A real SMOTE run repeats this process many times, with different base points, different neighbors, and different random λ values, until it reaches the requested sampling level.
What SMOTE Does and Does Not Do
SMOTE does | SMOTE does not do |
Creates new synthetic training examples via interpolation | Collect new real-world evidence |
Can reduce exact-duplicate oversampling artifacts | Guarantee improved generalization |
Works alongside most downstream classifiers | Automatically solve label noise |
Lets you tune the target class ratio | Necessarily produce a 50/50 split — that isn't always requested or optimal |
Adds density to under-represented feature-space regions | Replace proper, leakage-safe evaluation |
Belongs strictly inside the training partition | Belong in the validation or test set |
Changes the training distribution | Directly set the classifier's decision threshold |
— | Leave predicted-probability calibration unaffected |
SMOTE vs. Random Oversampling and Undersampling
Method | Core mechanism | Main advantage | Main risk | Data change | Typical use |
Random oversampling | Duplicates existing minority rows | Simple, no new assumptions | Exact duplicates can encourage overfitting | Adds rows (duplicates) | Quick baseline |
SMOTE | Interpolates between minority neighbors | Adds variety instead of copies | Can create unrealistic points near boundaries or outliers | Adds rows (synthetic) | Moderate imbalance, numeric features |
Random undersampling | Removes majority rows | Fast, reduces dataset size | Discards potentially useful majority information | Removes rows | Very large majority class |
Class weighting | Penalizes minority errors more in the loss function | No new or removed rows | Doesn't add minority-region resolution | No data change | Tree ensembles, logistic regression |
Combined over/undersampling (e.g., SMOTEENN) | SMOTE plus a cleaning/undersampling pass | Removes noisy or ambiguous points after synthesis | More complex tuning surface | Adds and removes rows | Noisy overlapping boundaries |
Duplicated points give a model repeated exposure to the exact same location, which can push decision boundaries to memorize particular rows. Interpolated points instead populate the space around real observations, which can encourage smoother decision boundaries — but neither approach is universally superior; performance depends on data geometry, and SMOTE is not guaranteed to beat class weighting or random oversampling on every dataset [2].
Essential SMOTE Parameters
The current imbalanced-learn SMOTE class exposes three parameters practitioners use most often: sampling_strategy, random_state, and k_neighbors [2].
sampling_strategy: Controls how much oversampling occurs. As a string, 'auto' (the default) resamples all classes except the majority to match it. As a float, it sets the desired ratio of minority-to-majority samples after resampling — but this float form is restricted to binary classification only [2]. As a dictionary, it lets you specify an exact target count per class.
random_state: Fixes the seed for the internal random number generator, making a specific SMOTE run reproducible. A fixed seed guarantees you can reproduce the same synthetic points, not that the model will generalize well — reproducibility and generalization are separate concerns.
k_neighbors: The number of nearest minority neighbors considered when interpolating (default 5) [2].
A perfectly balanced 1:1 class ratio is a convenient default, not an optimal target for every problem. Some datasets perform better with partial balancing (for example, moving from 1:100 to 1:10) rather than pushing all the way to 1:1.
Correct Python Implementation
Install the library once if needed: pip install imbalanced-learn
Example A: Basic Demonstration (teaching only, not an evaluation workflow)
from collections import Counter
from sklearn.datasets import make_classification
from imblearn.over_sampling import SMOTE
# Create an imbalanced binary classification dataset
X, y = make_classification(
n_samples=2000, n_features=10, n_informative=5,
n_redundant=2, weights=[0.95, 0.05],
n_clusters_per_class=1, random_state=42
)
print("Before SMOTE:", Counter(y))
sm = SMOTE(random_state=42, k_neighbors=5)
X_resampled, y_resampled = sm.fit_resample(X, y)
print("After SMOTE:", Counter(y_resampled))This is a simplified demonstration to show the mechanics of fit_resample. It is not the recommended evaluation workflow, because it resamples the entire dataset with no train/test separation.
Example B: Leakage-Safe Pipeline
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import classification_report, roc_auc_score, average_precision_score
from imblearn.pipeline import Pipeline as ImbPipeline
from imblearn.over_sampling import SMOTE
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.25, stratify=y, random_state=42
)
pipeline = ImbPipeline([
("scaler", StandardScaler()),
("smote", SMOTE(random_state=42, k_neighbors=5)),
("clf", LogisticRegression(max_iter=1000, random_state=42)),
])
pipeline.fit(X_train, y_train) # SMOTE only sees X_train, y_train
y_pred = pipeline.predict(X_test)
y_scores = pipeline.predict_proba(X_test)[:, 1]
print(classification_report(y_test, y_pred))
print("ROC-AUC:", roc_auc_score(y_test, y_scores))
print("Average precision:", average_precision_score(y_test, y_scores))Note the import: imblearn.pipeline.Pipeline, not sklearn.pipeline.Pipeline. The scikit-learn Pipeline class does not support resampling steps that change the number of rows, so a sampler like SMOTE must go inside an imbalanced-learn pipeline [8]. The test set is never touched by SMOTE or by the scaler's fit step — only transform.
Example C: Stratified Cross-Validation
from sklearn.model_selection import StratifiedKFold, cross_validate
cv = StratifiedKFold(n_splits=5, shuffle=True, random_state=42)
scoring = {
"avg_precision": "average_precision",
"recall": "recall",
"f1": "f1",
"balanced_accuracy": "balanced_accuracy",
"roc_auc": "roc_auc",
}
results = cross_validate(pipeline, X_train, y_train, cv=cv, scoring=scoring)
for metric in scoring:
print(metric, results[f"test_{metric}"].mean())Because pipeline includes SMOTE, cross_validate refits scaling and SMOTE independently inside each training fold [9]. Exact numeric results depend on your data, library version, and random state, so treat any specific number you see elsewhere as illustrative rather than a promise of what you will observe.
Data Leakage: The Most Important Implementation Mistake
Applying SMOTE to the entire dataset before splitting it into train and test partitions is the single most common and most damaging SMOTE mistake. When this happens, synthetic points generated using information from what will become the test set can end up back in the training set (or vice versa), and the test set itself may become artificially balanced — meaning it no longer represents the real-world class distribution the model will face in production [8]. Resampling the entire dataset before cross-validation causes the same problem, one fold at a time.
The correct rule, stated plainly: split first, and fit SMOTE only on each training partition or training fold. Validation and test sets should keep their naturally occurring class distribution unless there is a specific, justified evaluation reason to do otherwise [9].
Step | Incorrect workflow | Correct workflow |
1 | Apply SMOTE to all data | Reserve an untouched test set |
2 | Split or cross-validate afterward | Put preprocessing, SMOTE, and the model in one pipeline |
3 | Report performance | Fit or cross-validate the pipeline on training data only |
4 | — | Evaluate once on the untouched test set |
This same leakage principle applies beyond resampling. Fitting a scaler, an imputer, or a feature-selection step on the full dataset — instead of learning those transformations only from training data — causes the same category of inflated, misleading results [9].
Feature Scaling, Distance, and Preprocessing
SMOTE relies entirely on nearest-neighbor relationships, so the scale of each feature directly affects which points are treated as "close." A feature measured in the tens of thousands (annual income) can dominate distance calculations over a feature measured in single digits (number of dependents) unless both are standardized or normalized first.
Practical considerations:
Standardization/normalization should be learned only from training data, then applied to validation/test data — and it belongs inside the same pipeline as SMOTE.
Missing-value imputation must also be fit on training data only; imputing before splitting is another leakage source.
One-hot-encoded categories and ordinal features interpolate poorly under plain SMOTE, since fractional values between two one-hot columns are not meaningful (see the next section).
Binary indicators interpolated by standard SMOTE can produce fractional values like 0.4, which have no natural interpretation.
Sparse matrices, high-dimensional data, and text embeddings make nearest-neighbor search less stable, since distance concentrates and "nearest" neighbors become less distinctive as dimensionality grows.
There is no single universal preprocessing order that fits every dataset; the right sequence depends on which feature types are present and which sampler variant is chosen.
SMOTE With Categorical and Mixed Data
Vanilla SMOTE assumes continuous features that can be meaningfully interpolated. Raw nominal categories (like "region: North/South/East/West") cannot be interpolated this way — averaging category code 1 and category code 3 to get 2 does not produce a valid, real category, and interpolating across one-hot columns can create nonsensical combinations (e.g., a row that is 60% "North" and 40% "South" simultaneously).
Two purpose-built variants address this:
SMOTENC — for datasets containing a mix of continuous and categorical features. It interpolates numeric features normally while handling categorical features by taking the value of one of the neighboring points rather than blending category codes [3].
SMOTEN — for datasets that are categorical-only.
from imblearn.over_sampling import SMOTENC
# Suppose columns 2 and 5 (zero-indexed) are categorical
smote_nc = SMOTENC(categorical_features=[2, 5], random_state=42)
X_resampled, y_resampled = smote_nc.fit_resample(X_train, y_train)Always verify the categorical-feature specification format for the library version in use, since encoding conventions can change between releases [3].
Major SMOTE Variants and Related Methods
Method | What it changes | Region emphasized | Potential benefit | Potential failure mode | Test it when |
Borderline-SMOTE | Only oversamples minority points near the decision boundary | Borderline/ambiguous region | Focuses synthesis where it matters most for separation | Can amplify noise if the "borderline" is actually mislabeled data | Classes overlap moderately near the boundary |
SVM-SMOTE | Uses an SVM to identify support-vector-adjacent minority points | Boundary defined by a support-vector model | Can better target hard cases in complex boundaries | Sensitive to SVM hyperparameters | You already use SVM-style boundaries |
KMeans-SMOTE | Clusters data first, then applies SMOTE within dense minority clusters | Dense minority sub-clusters | Avoids bridging separate minority subgroups | Extra clustering step to tune | Minority class has clear sub-clusters [12] |
SMOTENC | Interpolates numeric features, handles categorical separately | Mixed-type feature space | Valid synthesis for real-world tabular data | More complex setup than plain SMOTE | Mixed continuous + categorical data [3] |
SMOTEN | Handles categorical-only data | Fully categorical feature space | Avoids invalid numeric interpolation | Limited to categorical-only datasets | All-categorical tabular data |
SMOTEENN | SMOTE followed by Edited Nearest Neighbours cleaning | Noisy/ambiguous synthetic points | Removes low-quality synthetic and majority points near the boundary | Can remove more data than expected | Noisy, overlapping classes |
SMOTETomek | SMOTE followed by Tomek-link removal | Overlapping pairs at the boundary | Sharper boundary after cleanup | Adds another tuning step | Boundary overlap with mislabeled-looking pairs |
ADASYN | Adaptively generates more synthetic points for harder-to-learn minority examples | Minority points near the majority boundary | Concentrates effort on difficult regions | Can over-focus on noisy borderline points | Minority difficulty is uneven across the class |
ADASYN is a related but distinct adaptive oversampling method, not simply another name for standard SMOTE. Where SMOTE distributes new points fairly evenly across minority neighborhoods, ADASYN weights generation toward minority examples that are harder to classify, based on how many majority neighbors surround them [7].
Advantages of SMOTE
Discussed conditionally, since results depend on data geometry, preprocessing, model family, validation design, and the chosen metric:
Avoids relying solely on exact duplication, which can reduce (though not eliminate) some overfitting patterns tied to repeated identical rows.
Can improve representation of a minority region a classifier previously had too little data to learn from.
Works with many downstream classifiers, including logistic regression, tree ensembles like random forest and XGBoost, and others.
Available in mature, actively maintained open-source tooling (imbalanced-learn), which integrates with scikit-learn conventions.
Useful as a benchmark method to compare against class weighting and other alternatives.
Offers tunable sampling ratios and multiple variants, so it can be adapted rather than treated as one-size-fits-all.
Limitations and Failure Modes
Boundary interpolation can generate points that cross into majority territory when classes overlap.
Noisy labels get amplified, since SMOTE treats every minority label as trustworthy ground truth.
Synthetic samples around outliers faithfully reproduce whatever noise surrounds a freak observation.
Bridging disconnected minority clusters can create points in a "no man's land" between two unrelated minority subgroups.
Unrealistic feature combinations are especially likely with mixed categorical/continuous data handled incorrectly.
Poor distance measures (unscaled features, high dimensionality) destabilize the whole nearest-neighbor mechanism.
Small minority classes may not have enough points to support the requested k_neighbors.
Time-dependent, grouped, spatially correlated, or multilabel data each violate SMOTE's implicit assumption that any two nearby minority points are interchangeable evidence.
Sparse text data and very high-dimensional embeddings weaken "nearest neighbor" as a meaningful concept.
Changed training priors mean the model's learned class balance no longer matches deployment reality.
Probability calibration can shift because the model was trained on an artificially altered class ratio.
Computational cost rises with dataset size and neighbor-search complexity, especially for advanced variants like KMeans-SMOTE.
Fairness and subgroup effects deserve scrutiny: oversampling can shift how models perform across demographic or operational subgroups in ways that are easy to overlook if only aggregate metrics are checked.
A synthetically balanced training set does not imply minority cases will be equally common in production — that ratio is a property of the real world, not something resampling changes.
Time Series, Grouped Data, and Other Special Settings
Random interpolation and ordinary stratified splitting can be invalid when observations carry temporal, patient-level, customer-level, device-level, or household-level dependencies. A synthetic point built by blending two points from different time periods may not represent anything plausible at the "time" it is implicitly placed at.
Practical adjustments:
Time-aware splits — train only on the past, test on the future, to avoid leaking tomorrow's information into today's model.
Group-aware cross-validation — keep every record from the same entity (patient, account, device) inside a single fold, so the model is never evaluated on an entity it partially trained on.
Concept drift awareness — synthetic points assume the past minority pattern still holds; if the pattern is shifting, synthesis based on old data can mislead the model, a dynamic covered in more depth in this piece on model generalization.
Domain constraints — physically or logically impossible synthetic combinations should be checked for and avoided.
SMOTE is not automatically appropriate in these settings; each one requires deliberate validation-design choices, not just a resampling step bolted onto a standard pipeline.
How to Evaluate a Model After SMOTE
Accuracy alone is frequently insufficient on imbalanced problems, because a model can score well by ignoring the minority class entirely. A fuller evaluation toolkit includes:
Confusion matrix — the foundation showing true/false positives and negatives.
Recall (sensitivity) — the share of actual minority cases correctly identified.
Precision — the share of predicted-positive cases that are actually positive.
Specificity — the true-negative rate, useful in clinical and screening contexts.
F1 and F-beta — harmonic means of precision and recall, with F-beta letting you weight recall or precision more heavily depending on which error costs more [14].
Balanced accuracy — the average of recall computed per class, useful when classes are imbalanced [16].
ROC-AUC — measures ranking quality across all thresholds, but can look optimistic on severely imbalanced data because it is influenced by the large number of true negatives.
Precision-recall curve and average precision (PR-AUC) — often more informative than ROC-AUC specifically because they ignore the (usually huge) true-negative count and focus on how well the model finds and correctly labels the minority class [14].
Matthews correlation coefficient (MCC) — a single balanced summary statistic that accounts for all four confusion-matrix cells, useful when both classes matter.
Cost-sensitive evaluation — weighting false positives and false negatives by their real business or clinical cost.
Threshold selection — a separate decision from oversampling; SMOTE changes what the model learns, while the operating threshold decides where you draw the line between "predict positive" and "predict negative" on the resulting probability scores.
Calibration — checking whether predicted probabilities reflect true likelihoods, since resampling the training distribution can distort them.
Subgroup evaluation and repeated validation/confidence intervals — checking whether results hold across meaningful subpopulations and across multiple random splits or seeds, not just a single lucky run.
ROC-AUC and PR-based metrics are not interchangeable: ROC-AUC treats false positive rate symmetrically with true positive rate, while precision-recall metrics zero in on minority-class performance, which is usually the actual objective in imbalanced problems.
Designing a Fair Experiment
A defensible comparison holds the following constant across every method tested: data splits, preprocessing, feature set, model family, hyperparameter-search budget, and evaluation metrics. A reasonable candidate set to compare includes:
No resampling (baseline)
Class-weighted model
Random oversampling
SMOTE
At least one SMOTE variant (e.g., Borderline-SMOTE or ADASYN)
Optionally, undersampling or an ensemble method such as a balanced random forest
Use nested cross-validation so hyperparameter selection happens on an inner loop while the outer loop estimates final performance — this keeps tuning decisions from leaking into the reported number [9]. Never pick the "winning" method by repeatedly checking the untouched test set; that turns the test set into a de facto validation set and reintroduces leakage. Report variability across folds or repeated runs wherever feasible, since a single split can make a mediocre method look artificially strong.
When SMOTE Is a Reasonable Choice
SMOTE is worth testing when:
The problem is tabular classification with numeric or properly encoded features.
Feature-space neighborhoods carry genuine meaning (similar points really do represent similar cases).
The minority class has enough examples to support a sensible k_neighbors value.
A leakage-safe evaluation pipeline is already in place.
A simple baseline model demonstrably misses important minority patterns.
None of these conditions guarantee an improvement — they only make SMOTE a reasonable candidate to test empirically against alternatives.
When Not to Use SMOTE
Caution or avoidance is warranted when:
Label noise is severe, since SMOTE will faithfully replicate incorrect labels.
The minority class has extremely few observations, undermining the nearest-neighbor mechanism.
Nominal features are being handled as plain numbers instead of using SMOTENC/SMOTEN.
Strong temporal or group dependence exists without a time- or group-aware validation design.
Data is images, raw audio, or raw text, where feature-space interpolation of pixels or raw tokens rarely has a valid interpretation (embeddings pretrained for such data may behave differently, but this needs careful, separate validation).
Hard physical or logical constraints exist that interpolation could violate.
Classes overlap heavily, making synthesis likely to blur rather than sharpen the boundary.
Calibrated probabilities are central to production decisions and haven't been re-validated after resampling.
A simpler class-weighted baseline already performs adequately.
The task is really unsupervised anomaly detection without representative labeled minority examples to interpolate between.
Alternatives to SMOTE
Gathering more genuine minority examples, when feasible, addresses the root data-scarcity problem directly.
Improving label quality reduces the risk of amplifying noise, whichever resampling method is used.
Class weights / cost-sensitive learning adjust the loss function without changing the data at all.
Threshold adjustment shifts the classifier's decision cutoff without retraining.
Random oversampling / undersampling / NearMiss-style informed undersampling offer simpler resampling alternatives.
Balanced random forests and EasyEnsemble-style ensembles combine sampling with model architecture.
Focal loss down-weights easy examples during neural-network training, indirectly addressing imbalance.
Anomaly or novelty detection reframes the problem entirely when minority examples are too sparse or too different from a "classification" framing.
Domain-specific data augmentation and, cautiously, generative approaches can create additional training signal in some settings, though they carry their own validation burden.
Better features, calibration methods, and decision-theoretic approaches address related but distinct parts of the imbalance problem.
These methods target different pieces of the puzzle — data scarcity, model loss weighting, decision thresholds, or feature quality — so they are complements to test alongside SMOTE, not uniform substitutes for it.
Decision Framework
Question | Why it matters |
Is the problem actually harmed by imbalance, or is a simple baseline already adequate? | Avoids solving a problem that may not exist |
Are labels reliable? | Noisy labels undermine any resampling method |
Are neighborhoods meaningful in feature space? | SMOTE assumes "near" points are truly similar |
Are features continuous, categorical, or mixed? | Determines SMOTE vs. SMOTENC vs. SMOTEN |
Are there enough minority samples for a sensible k? | Too few examples break the neighbor search |
Is there temporal or group structure? | May invalidate standard interpolation and splitting |
Is probability calibration important? | Resampling can distort predicted probabilities |
Which baseline should be tested first? | A no-resampling and a class-weighted baseline anchor the comparison |
Which metrics represent the real objective? | Recall, precision, F1, PR-AUC, or MCC usually matter more than accuracy |
How will leakage be prevented? | Split first; resample only inside training folds |
Treat SMOTE as a candidate to validate empirically against alternatives — not as an automatic preprocessing requirement for every imbalanced dataset.
Best-Practices Checklist
Establish an untouched, no-resampling baseline first.
Split data before any resampling occurs.
Use an imbalanced-learn pipeline (imblearn.pipeline.Pipeline) whenever a sampler is involved.
Keep validation and test data untouched by SMOTE.
Scale or preprocess appropriately, fitting only on training data.
Choose the sampler variant that matches your feature types (SMOTE, SMOTENC, or SMOTEN).
Tune the sampling ratio rather than defaulting to a forced 1:1 split.
Tune k_neighbors carefully, especially with small minority classes.
Inspect synthetic plausibility where feasible (e.g., visualize low-dimensional projections).
Compare against class weighting and simpler alternatives, not just against "no resampling."
Use minority-relevant metrics (recall, F1, PR-AUC, balanced accuracy, MCC).
Evaluate calibration whenever predicted probabilities drive downstream decisions.
Respect time and group boundaries in the validation design.
Report variability across folds or repeated runs.
Document the entire resampling workflow so results can be audited later.
Final Synthesis
SMOTE fundamentally does one thing: it manufactures new training examples for a rare class by interpolating between real neighbors in feature space, instead of copying rows outright. This interpolation can help a classifier see more of the minority region and build a steadier decision boundary — but the same mechanism can just as easily amplify noise, bridge unrelated clusters, or manufacture unrealistic combinations when the underlying geometry doesn't cooperate.
Because SMOTE changes what the model trains on, leakage-safe evaluation is not optional. Fitting SMOTE anywhere near validation or test data — or resampling before a train/test split — inflates reported performance in a way that will not survive contact with production data. And no resampling technique, however well implemented, substitutes for clean labels, meaningful features, sound feature selection, or domain understanding of why the minority class is rare in the first place. SMOTE is a tool to test rigorously against alternatives, not a step to apply reflexively.
FAQ
What does SMOTE stand for?
SMOTE stands for Synthetic Minority Over-sampling Technique. It was introduced by Chawla, Bowyer, Hall, and Kegelmeyer in a 2002 paper published in the Journal of Artificial Intelligence Research [1]. The name describes exactly what it does: it over-samples (adds more examples of) the minority class using synthetic, generated data points rather than real newly collected observations.
Is SMOTE the same as duplicating minority samples?
No. Random oversampling duplicates existing minority rows exactly, so the same point can appear many times in training. SMOTE instead creates new points located between a real minority observation and one of its nearest minority neighbors. This gives the model variety in the minority region rather than repeated exposure to identical rows, though both approaches add rows without adding truly new evidence.
How does SMOTE generate a new point?
SMOTE picks a minority observation, finds one of its k nearest minority neighbors, and calculates a new point using x_new = x_i + λ(x_neighbor − x_i), where λ is a random number between 0 and 1. This formula places the synthetic point somewhere along the straight line connecting the two real points, with λ controlling exactly how far along that line it falls.
Should SMOTE be applied before or after the train/test split?
Always after. SMOTE must be fit only on the training partition (or, in cross-validation, on each training fold individually), never on the full dataset before splitting. Applying it beforehand lets information influence points that end up in the test set, inflating reported performance and producing a test set that no longer reflects the real-world class distribution [8][9].
Can SMOTE be used with categorical data?
Plain SMOTE is not designed for raw categorical features, because interpolating between category codes produces invalid values. Two dedicated variants exist instead: SMOTENC for datasets with a mix of continuous and categorical features, and SMOTEN for datasets that are entirely categorical [3]. Both handle categorical columns without invalid numeric blending.
Does SMOTE work for multiclass classification?
Yes. The original SMOTE implementation supports multiclass resampling using a one-vs.-rest scheme, oversampling each minority class relative to the majority [2]. Multiclass imbalance adds complexity, though, since several classes may need different sampling ratios and evaluation should track per-class performance rather than a single aggregate score.
What value of k_neighbors should be used?
The default is 5 in most implementations, and it is a reasonable starting point for moderate-sized minority classes [2]. Smaller values keep synthesis very local, which can help with tight sub-clusters; larger values pull from a wider neighborhood, which can smooth over noise but risks mixing dissimilar points. If the minority class has very few examples, k must be reduced below the class size or the neighbor search will fail.
Does SMOTE always improve performance?
No. Whether SMOTE helps depends on data geometry, feature quality, model family, and the evaluation metric chosen. On some datasets it clearly improves minority-class recall; on others, class weighting or no resampling at all performs just as well or better. SMOTE should always be benchmarked against simpler alternatives rather than assumed to help by default.
Can SMOTE cause overfitting?
It can, particularly if synthetic points are generated in noisy or outlier-adjacent regions, or if the sampling ratio is pushed aggressively toward 1:1 on a very small minority class. Because synthetic points are derived from a limited set of real examples, heavy oversampling can cause a model to overfit to the specific structure of those few original points, even though the rows themselves are not literal duplicates.
What is the difference between SMOTE and ADASYN?
SMOTE distributes new synthetic points fairly evenly across minority neighborhoods. ADASYN (Adaptive Synthetic Sampling) instead generates more synthetic points for minority examples that are harder to classify — specifically, those surrounded by more majority-class neighbors [7]. ADASYN is a related but distinct method, not another name for standard SMOTE.
What is the difference between SMOTE and class weighting?
SMOTE changes the training data itself by adding synthetic minority rows. Class weighting leaves the data unchanged and instead adjusts the loss function so that minority-class errors are penalized more heavily during training. Both aim to counter imbalance, but they act at different stages of the pipeline, and each can be combined with the other.
Which metrics should be used after SMOTE?
Recall, precision, F1 or F-beta score, balanced accuracy, the precision-recall curve, average precision (PR-AUC), and Matthews correlation coefficient are generally more informative than accuracy for imbalanced problems [14][16]. ROC-AUC can also be useful but should be interpreted alongside PR-based metrics rather than in isolation, since it can look optimistic when negatives vastly outnumber positives.
Can SMOTE be used for time-series data?
Standard SMOTE is risky for time-series data because interpolating between two points from different time periods can create a synthetic observation that isn't temporally plausible, and ordinary random splitting can leak future information into training. Time-aware validation splits and domain-specific augmentation are usually safer starting points than applying vanilla SMOTE directly to sequential data.
Does SMOTE affect probability calibration?
Yes, it can. Because SMOTE changes the class ratio the model is trained on, the resulting predicted probabilities may no longer reflect true real-world likelihoods. If calibrated probabilities matter for a downstream decision, it's worth checking calibration after resampling and, if needed, applying a separate calibration step.
When should SMOTE be avoided?
SMOTE is best avoided or used cautiously with severe label noise, extremely small minority classes, unprocessed categorical features, strong temporal or group dependence without appropriate validation design, raw image/audio/text data without a validated feature representation, heavily overlapping classes, and settings where calibrated probabilities are critical and haven't been re-checked after resampling.
Is SMOTE useful for deep learning?
SMOTE is used far less often in deep learning on raw images, audio, or text, where feature-space interpolation of pixels or tokens rarely produces meaningful examples. Deep-learning practitioners more commonly address imbalance with class-weighted loss functions, focal loss, or data augmentation designed for the specific data type, though SMOTE can still apply to structured/tabular inputs to a neural network.
Key Takeaways
SMOTE creates synthetic minority examples by interpolating between real neighboring points — it does not duplicate rows or collect new real-world evidence.
The core formula, x_new = x_i + λ(x_neighbor − x_i), places each synthetic point somewhere along the line between two real minority observations.
SMOTE must be fit only on training data or training folds; applying it before a train/test split is a serious and common leakage mistake.
Feature type matters: use SMOTENC or SMOTEN for categorical or mixed data rather than plain SMOTE.
A forced 1:1 class balance is not automatically optimal — sampling ratio and k_neighbors both deserve tuning.
Accuracy is an unreliable metric on imbalanced data; recall, precision, F1, balanced accuracy, PR-AUC, and MCC give a far more honest picture.
SMOTE is one candidate among several (class weighting, undersampling, ensembles) and should be benchmarked, not assumed superior.
Special data structures — time series, grouped/repeated-measure data, categorical features, images/audio/text — each require careful, sometimes different, handling.
Actionable Next Steps
Quantify the class imbalance ratio and the real-world cost of false negatives vs. false positives.
Establish a no-resampling baseline model to know what you're improving on.
Choose evaluation metrics before touching the data — recall, F1, PR-AUC, and balanced accuracy are strong defaults for imbalanced problems.
Create an untouched test set using a stratified split before any resampling.
Build a leakage-safe imblearn.pipeline.Pipeline that includes preprocessing, SMOTE, and the classifier.
Compare SMOTE against class weighting, random oversampling, and at least one SMOTE variant.
Tune sampling ratio and k_neighbors inside cross-validation, not against the test set.
Inspect errors, subgroup performance, and calibration, not just aggregate scores.
Run one final evaluation on the untouched test set.
Document the resampling decision, parameters used, and rationale for future audits.
Glossary
Average precision — The area under the precision-recall curve, summarizing precision across all recall levels into a single number.
Balanced accuracy — The average of recall computed separately for each class, useful when class sizes differ substantially.
Calibration — How closely a model's predicted probabilities match true observed frequencies.
Class imbalance — A situation where one class has substantially more examples than another in a labeled dataset.
Cross-validation — A method of splitting data into multiple folds to train and evaluate a model several times for a more stable performance estimate.
Data leakage — When information that would not be available at prediction time influences model training or evaluation, inflating reported performance.
Decision threshold — The cutoff on a predicted probability above which a model outputs the positive class.
F1 score — The harmonic mean of precision and recall, balancing both into a single metric.
Feature space — The multi-dimensional space defined by a dataset's input variables, in which each observation is a point.
Interpolation — Estimating a new value that lies between two known values, such as the point SMOTE creates between two neighbors.
Majority class — The class with more examples in an imbalanced dataset.
Minority class — The class with fewer examples in an imbalanced dataset, often the class of greater practical interest.
Nearest neighbor — A data point that is closest to a given point according to a chosen distance measure.
Oversampling — Increasing the number of examples in the minority class, either by duplication or synthesis.
Pipeline — A chained sequence of preprocessing and modeling steps that can be fit and evaluated as a single unit.
Precision — The proportion of predicted-positive cases that are actually positive.
Precision-recall curve — A plot showing the trade-off between precision and recall as the decision threshold varies.
Recall — The proportion of actual positive cases that a model correctly identifies.
ROC-AUC — The area under the receiver operating characteristic curve, summarizing a classifier's ranking ability across thresholds.
Sampling strategy — The parameter controlling how much and which classes to resample.
SMOTENC — A SMOTE variant for datasets with both continuous and categorical features.
Synthetic sample — A generated data point that did not exist in the original dataset, created here through interpolation.
Undersampling — Reducing the number of majority-class examples to lessen imbalance.
ADASYN — Adaptive Synthetic Sampling, a related but distinct oversampling method that focuses new points on harder-to-classify minority examples.
Sources & References
Chawla, N.V., Bowyer, K.W., Hall, L.O., & Kegelmeyer, W.P. (2002). "SMOTE: Synthetic Minority Over-sampling Technique." Journal of Artificial Intelligence Research, 16, 321–357. https://www.researchgate.net/publication/220543125_SMOTE_Synthetic_Minority_Over-sampling_Technique
imbalanced-learn developers. "SMOTE — imbalanced-learn documentation." https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.SMOTE.html
imbalanced-learn developers. "SMOTENC — imbalanced-learn documentation." https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.SMOTENC.html
imbalanced-learn developers. "BorderlineSMOTE — imbalanced-learn documentation." https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.BorderlineSMOTE.html
imbalanced-learn developers. "SMOTEENN — imbalanced-learn documentation." https://imbalanced-learn.org/stable/references/generated/imblearn.combine.SMOTEENN.html
imbalanced-learn developers. "API reference: SMOTEN, SVMSMOTE, ADASYN, SMOTETomek — imbalanced-learn documentation." https://imbalanced-learn.org/stable/references/index.html
He, H., Bai, Y., Garcia, E.A., & Li, S. (2008). "ADASYN: Adaptive Synthetic Sampling Approach for Imbalanced Learning." IEEE International Joint Conference on Neural Networks (IJCNN 2008), referenced via imbalanced-learn and GeeksforGeeks summaries of the method. https://www.geeksforgeeks.org/machine-learning/smote-for-imbalanced-classification-with-python/
imbalanced-learn developers. "Common pitfalls and recommended practices: Data leakage — imbalanced-learn documentation." https://imbalanced-learn.org/stable/common_pitfalls.html
scikit-learn developers. "Common pitfalls and recommended practices — scikit-learn documentation." https://scikit-learn.org/stable/common_pitfalls.html
Last, F., Douzas, G., & Bacao, F. (2017). "Oversampling for Imbalanced Learning Based on K-Means and SMOTE." arXiv:1711.00837, cited directly in imbalanced-learn's KMeansSMOTE documentation. https://imbalanced-learn.org/stable/references/generated/imblearn.over_sampling.KMeansSMOTE.html
Han, H., Wang, W.-Y., & Mao, B.-H. (2005). "Borderline-SMOTE: A New Over-Sampling Method in Imbalanced Data Sets Learning." International Conference on Intelligent Computing (ICIC 2005), 878–887, cited in imbalanced-learn's BorderlineSMOTE documentation.
scikit-learn developers. "3.4. Metrics and scoring: quantifying the quality of predictions — scikit-learn documentation." https://scikit-learn.org/stable/modules/model_evaluation.html
Google Search Central. FAQ (FAQPage) structured-data documentation, updated with a deprecation notice effective May 7, 2026, stating that FAQ rich results no longer appear in Google Search, with related reporting support removed in stages through June and August 2026.
Schema.org. "BlogPosting" and "FAQPage" type definitions, used as the vocabulary basis for this article's structured data.