SMOTE + ENN in Machine Learning

SMOTE's Achilles Heel: Noisy Synthetic Samples

SMOTE transformed imbalanced learning when it was introduced in 2002, but practitioners quickly discovered a recurring problem: SMOTE generates synthetic minority samples by interpolating between existing minority class neighbors, and some of those synthetic samples land in regions dominated by the majority class. These "boundary-violating" synthetics confuse classifiers and increase false positive rates.

Consider a credit card fraud detection system at a company like Razorpay processing millions of transactions daily. The fraud rate might be 0.1% — a severe 1:1000 imbalance. SMOTE can generate enough synthetic fraud examples to balance the training set, but some of those synthetics will be interpolations between legitimate-looking fraud patterns and genuine fraud, landing in regions of feature space where legitimate transactions dominate. The classifier then learns to flag legitimate transactions as fraud, driving up false positives and creating customer friction.

The ENN Solution: Clean After You Generate

Edited Nearest Neighbors (ENN), proposed by Dennis Wilson in 1972, is an elegantly simple data cleaning algorithm: for each sample in the dataset, examine its k nearest neighbors. If the majority of those neighbors belong to a different class, the sample is "misclassified by its neighbors" and is removed. It's essentially a local voting mechanism — if your closest neighbors disagree with your label, you're probably noise.

Batista, Prati, and Monard had the insight to combine these two techniques sequentially: first apply SMOTE to balance the dataset, then apply ENN to clean up the mess. Their 2004 paper, published in ACM SIGKDD Explorations Newsletter, systematically compared 10 different balancing strategies and found that SMOTE+ENN consistently produced the best results, particularly on datasets with overlapping class distributions.

Why Not Just Use Borderline-SMOTE?

Borderline-SMOTE (Han et al., 2005) takes a different approach: instead of cleaning after generation, it restricts generation to boundary samples only. This is effective but limited — it doesn't clean the original majority class samples that contribute to boundary confusion. SMOTEENN's advantage is that it cleans BOTH synthetic minority samples AND original majority samples, producing globally cleaner decision boundaries.

The Evolution: From Research to Production Standard

Since the 2004 paper, SMOTEENN has become a production staple. The imbalanced-learn library (imblearn) included it in its earliest releases as imblearn.combine.SMOTEENN, making it accessible to any scikit-learn-compatible pipeline. By 2024, research surveys found SMOTEENN to be among the most cited hybrid resampling techniques in healthcare AI, appearing in 38% of papers surveyed on imbalanced medical datasets.

Key Insight: SMOTEENN's power comes from the asymmetry of its two phases. SMOTE is generous — it adds many synthetic samples to expand minority coverage. ENN is strict — it removes any sample that looks out of place. The combination yields a dataset that is both balanced (thanks to SMOTE) and clean (thanks to ENN), resulting in sharper decision boundaries than either technique achieves alone.

The Two-Phase Strategy: Build, Then Prune

Imagine you're landscaping a garden that's wildly overgrown on one side (majority class) and nearly bare on the other (minority class). SMOTE is like planting many new seedlings on the bare side — it fills in the gaps. But some of those seedlings inevitably land too close to the overgrown side, creating a messy, tangled border zone where it's impossible to tell which side a plant belongs to.

ENN is the careful gardener who walks along the border, examines each plant, and removes any that are clearly in the wrong place — whether they're new seedlings that ended up too far over, or original overgrowth plants that were always in contested territory. After ENN's pass, you have a clean, well-defined border between the two sides.

Why Clean AFTER Generating?

This ordering is crucial and counterintuitive. You might think: "Why not clean the data first, then oversample?" The answer is that ENN's effectiveness depends on having enough samples to make meaningful neighborhood judgments. In a severely imbalanced dataset (1:100 ratio), most minority samples will have majority class neighbors simply because there are so few minority points — ENN would end up removing the very minority samples you're trying to preserve.

By applying SMOTE first, you flood the minority class region with synthetic samples, creating dense minority clusters. Now when ENN examines neighborhoods, minority samples have reasonable representation among their neighbors. ENN can then identify genuinely ambiguous samples — both synthetic minorities that landed in majority territory AND majority samples that sit in regions now claimed by the expanded minority class.

The Decision Boundary Perspective

Think of the decision boundary between two classes as a fence. SMOTE builds the fence wider (expanding minority territory), but it's a sloppy builder — some fence posts end up on the wrong side. ENN then walks along the fence and removes any post that's clearly in the wrong yard. The result is a cleaner, sharper fence than either technique produces alone.

This is why SMOTEENN typically outperforms both vanilla SMOTE (which leaves noisy synthetics in place) and pure ENN undersampling (which can only remove majority samples, never adding minority representation).

The Coffee Shop Analogy

You're building a customer churn prediction model for a coffee subscription service like Blue Tokai. Out of 10,000 customers, only 200 have churned (2% minority). SMOTE generates 9,800 synthetic churn examples, balancing to 50-50. But some synthetic churners have profiles nearly identical to loyal customers — they look like people who just had one quiet month, not genuine churners.

ENN examines each sample's 3 nearest neighbors. A synthetic churner whose 3 nearest neighbors are all loyal customers? Removed — it's in the wrong neighborhood. A loyal customer whose 3 nearest neighbors are all churners? Also removed — it's an ambiguous case that would confuse the model. The final dataset has perhaps 8,500 majority and 8,000 minority samples — not perfectly balanced, but much cleaner. The model trained on this data achieves better precision without sacrificing the recall gains from SMOTE.

Expert Insight: SMOTEENN's aggressiveness is both its strength and its risk. It removes more samples than SMOTETomek (which only removes Tomek link pairs), resulting in cleaner data but also smaller final datasets. If your original dataset is small, SMOTEENN might remove too many samples. For large datasets with noisy boundaries, it's often the superior choice.

Mathematical Formulation

SMOTEENN operates in two sequential phases on a training set $D = \{(\mathbf{x}_i, y_i)\}_{i=1}^{n}$ where $y_i \in \{0, 1\}$, with minority class $C_{\text{min}}$ having $n_{\text{min}}$ samples and majority class $C_{\text{maj}}$ having $n_{\text{maj}}$ samples, where $n_{\text{min}} \ll n_{\text{maj}}$.

Phase 1: SMOTE Oversampling

For each minority sample $\mathbf{x}_i \in C_{\text{min}}$:

1. Find the $k$ nearest minority class neighbors: $N_k(\mathbf{x}_i) = \{\mathbf{x}_{i_1}, \ldots, \mathbf{x}_{i_k}\}$

2. Generate synthetic samples by interpolation:

$\mathbf{x}_{\text{synth}} = \mathbf{x}_i + \lambda \cdot (\mathbf{x}_{i_j} - \mathbf{x}_i), \quad \lambda \sim \text{Uniform}(0, 1)$

where $\mathbf{x}_{i_j}$ is a randomly selected neighbor from $N_k(\mathbf{x}_i)$.

The number of synthetic samples generated is determined by the sampling_strategy parameter, targeting a ratio $\alpha_{\text{os}} = \frac{|C_{\text{min}}^{\text{new}}|}{|C_{\text{maj}}|}$.

After Phase 1, the intermediate dataset is: $D' = C_{\text{maj}} \cup C_{\text{min}} \cup S_{\text{synth}}$ where $|D'| = n_{\text{maj}} + n_{\text{min}} + |S_{\text{synth}}|$.

Phase 2: ENN Cleaning (Wilson's Editing Rule)

For each sample $(\mathbf{x}_i, y_i) \in D'$:

1. Find the $k_{\text{enn}}$ nearest neighbors in $D'$ (typically $k_{\text{enn}} = 3$)

2. Let $\hat{y}_i = \text{mode}(\{y_j : \mathbf{x}_j \in N_{k_{\text{enn}}}(\mathbf{x}_i)\})$ be the majority vote of neighbors

3. If $\hat{y}_i \neq y_i$, remove $\mathbf{x}_i$ from $D'$

The ENN removal criterion can be formalized as:

$D_{\text{final}} = \{(\mathbf{x}_i, y_i) \in D' : \hat{y}_i = y_i\}$

In other words, a sample survives ENN only if its nearest neighbors agree with its label. This removes:

• Synthetic minority samples that landed in majority-dominated regions
• Original majority samples that sit in regions now dominated by minority samples
• Original minority samples that were already ambiguous (rare but possible)

Formal Properties

Dataset size after SMOTEENN: Let $r$ denote the ENN removal rate. Then: $|D_{\text{final}}| = |D'| \cdot (1 - r) = (n_{\text{maj}} + n_{\text{min}} + |S_{\text{synth}}|) \cdot (1 - r)$

Typically $r \in [0.05, 0.30]$, meaning ENN removes 5-30% of the post-SMOTE dataset. The removal rate is higher when classes overlap significantly.

Imbalance after SMOTEENN: Unlike SMOTE alone, SMOTEENN does NOT guarantee a specific class ratio in the final dataset. SMOTE targets the ratio $\alpha_{\text{os}}$, but ENN may remove different proportions from each class, yielding a final ratio that deviates from $\alpha_{\text{os}}$. In practice, ENN typically removes more majority samples (those near the boundary) than minority samples, so the final dataset may be more balanced than $\alpha_{\text{os}}$ suggests.

Computational Complexity

• SMOTE phase: $O(n_{\text{min}}^2 \cdot d)$ for naive k-NN, $O(n_{\text{min}} \cdot d \cdot \log n_{\text{min}})$ with tree-based search
• ENN phase: $O(|D'|^2 \cdot d)$ for naive k-NN on the enlarged dataset, $O(|D'| \cdot d \cdot \log |D'|)$ with tree-based search
• Total: Dominated by ENN on the enlarged dataset: $O((n_{\text{maj}} + n_{\text{min}} + |S_{\text{synth}}|)^2 \cdot d)$

Since $|D'|$ can be up to $2 \cdot n_{\text{maj}}$ for full balancing, the ENN phase is typically the computational bottleneck.

Mathematical Caveat: ENN's removal is order-independent for a single pass but the result depends on $k_{\text{enn}}$. With $k_{\text{enn}} = 3$ (default), a sample is removed if 2 or more of its 3 nearest neighbors have a different label. Higher $k_{\text{enn}}$ values make ENN more aggressive, removing more samples. The imblearn implementation allows customizing both the SMOTE and ENN components independently.

SMOTEENN (SMOTE + Edited Nearest Neighbors) is a hybrid resampling technique that addresses one of the most persistent problems in imbalanced learning: the noisy synthetic samples that vanilla SMOTE introduces. By combining SMOTE's minority class oversampling with ENN's neighborhood-based cleaning, SMOTEENN produces training datasets that are both more balanced AND cleaner than what either technique achieves independently. The result is sharper decision boundaries, reduced false positives, and more stable cross-validation performance.

The technique operates in two sequential phases. First, SMOTE generates synthetic minority samples by interpolating between existing minority instances and their k nearest neighbors, expanding minority class coverage in feature space. Second, ENN evaluates every sample in the enlarged dataset — original majority, original minority, and synthetic alike — examining each sample's k nearest neighbors and removing any sample whose neighbors disagree with its label. This cleaning removes noisy synthetics that landed in majority-dominated regions, ambiguous majority samples near the boundary, and any pre-existing mislabeled data.

Proposed by Batista, Prati, and Monard in their influential 2004 paper, SMOTEENN has been validated across diverse domains: cancer diagnosis (achieving 98.19% accuracy across multiple cancer types), agricultural remote sensing (F1-score of 0.930 for crop lodging detection), credit card fraud detection (40% reduction in false positives vs vanilla SMOTE), and clinical health prediction (96.2% accuracy for stroke prediction). The technique is implemented in Python's imbalanced-learn library as imblearn.combine.SMOTEENN with a clean fit_resample() API that integrates seamlessly with scikit-learn pipelines.

However, SMOTEENN is not without trade-offs. It does not guarantee a specific class ratio (ENN's removal is data-dependent), it is 2-5x slower than vanilla SMOTE due to ENN's k-NN search on the enlarged dataset, and it can over-clean small datasets by removing informative boundary samples. Practitioners should compare SMOTEENN against vanilla SMOTE, SMOTETomek (a gentler cleaning alternative), and class weights using cross-validated minority class F1 before committing to it in production. For tree-based models, class weights often suffice; for k-NN, SVM, and neural networks on noisy data with overlapping classes, SMOTEENN is frequently the best choice.