RandomOverSampler: The Baseline Every SMOTE Variant Is Measured Against

Part of the SMOTE deep-dive series for optiontradingwithai.in — Shakti Tiwari, Nifty Option Trader & XGBoost Expert.

Disclaimer: Shakti Tiwari is NISM-Series-XII certified; not a SEBI-registered Research Analyst. Content is educational only.

Quick Answer

RandomOverSampler is the simplest oversampling method in imbalanced-learn: it duplicates minority-class rows uniformly at random, sampling with replacement, until every class is balanced. No new information is invented — only exact copies are made. That is precisely why it is the reference baseline: every fancy SMOTE variant (Borderline, SVM, KMeans, ADASYN) must beat naive duplication to earn its place in your pipeline. We cover when duplication is "good enough," the memorization risk it creates, and the shrinkage jitter that partially tames it.

Why This Matters

If you trade NIFTY options, you already live with imbalance. The "interesting" class — a clean directional edge, a rare volatility expansion, a profitable expiry setup — is almost always the minority. Your XGBoost model, fed raw EOD signatures, sees 95% "nothing happens" rows and 5% "real signal" rows. Left alone, the tree learns to shout "do nothing" and still score 95% accuracy. Useless.

So you reach for resampling. And the very first thing any serious practitioner should do — before installing Borderline-SMOTE, before tuning ADASYN's β, before anything — is run RandomOverSampler as a control.

Why? Because if a complicated synthetic sampler cannot beat "just copy the minority rows a bunch of times," then the complication is not buying you anything. RandomOverSampler is the yardstick. Chawla et al. (2002) literally introduced SMOTE as an improvement over random oversampling, so the original paper frames the whole family against this exact baseline. [SOURCE: Chawla et al. 2002, JAIR 16:321–357]

Our NSE stack is TWO-LAYER: Layer 1 = Dhan WebSocket live capture (shadow/predict-only); Layer 2 = EOD-audited XGBoost/LightGBM training core (walk-forward, cost-and-slippage). Imbalance handling (SMOTE or scale_pos_weight) is applied in Layer 2 inside CV, never on live data. RandomOverSampler, being the cheapest resampler, is the natural first thing we drop into Layer 2's CV loop.

Research Question / Hypothesis

RQ: For a strong, stochastic, bagged model like XGBoost, does naive random duplication (RandomOverSampler) perform close enough to interpolation-based SMOTE that the extra complexity is unjustified?

Hypothesis: As model stochasticity rises (subsampling, column sampling, bootstrap aggregation), the marginal benefit of SMOTE's synthetic interpolation shrinks, because the model already perturbs the data through its own randomness. RandomOverSampler then becomes a defensible, near-free baseline — but only up to a point, beyond which exact-duplicate memorization caps its ceiling.

This is the question the rest of the article works through.

Data & Methodology

The mechanism, exactly

RandomOverSampler balances classes by resampling the minority class with replacement. Call the majority count N_maj and the minority count N_min. To reach balance, the sampler draws N_maj − N_min additional minority rows, each drawn independently and uniformly from the N_min original minority rows. [SOURCE: imbalanced-learn RandomOverSampler documentation]

That means a specific minority row i can be copied zero, one, or many times in a single fit_resample call. The selection is a multinomial draw.

The math (DERIVED)

Let the imbalance ratio be IR = N_maj / N_min. The number of copies we must add is:

copies_to_add = N_maj − N_min = N_min · (IR − 1)

Each draw picks row i with probability 1 / N_min. Over copies_to_add independent draws, the expected number of times row i is selected is:

E[copies of row i] = (N_maj − N_min) · (1 / N_min) = IR − 1

So each minority row is expected to appear IR − 1 extra times. The total minority presence after resampling is N_min · IR = N_maj rows, matching the majority. Clean. [DERIVED]

Worked numerical example (DERIVED)

Suppose your NIFTY directional dataset has N_maj = 10,000 "no edge" days and N_min = 200 "real edge" days. Then:

• IR = 10,000 / 200 = 50
• copies_to_add = 9,800
• E[copies per minority row] = 50 − 1 = 49

After fit_resample, you hold 200 original minority rows + 9,800 copies = 10,000 minority rows. On average every one of those 200 days now shows up 50 times in the training set. This is the crux of the overfitting problem (next sections): the model sees those 200 days far more than the 10,000 majority days individually, and — critically — it sees exact copies, not variations.

Contrast with SMOTE (the whole point)

SMOTE does not copy. It interpolates. For each minority row x_i, SMOTE finds its k nearest minority neighbors, picks one neighbor x_zi, and synthesizes:

x_new = x_i + λ · (x_zi − x_i),   λ ~ Uniform(0, 1)

[SOURCE: Chawla et al. 2002]

The generated point lies on the line segment between two real minority examples. It is a new coordinate that never existed in your data — but lives in a plausible region of feature space. RandomOverSampler, by contrast, produces x_new = x_i exactly, repeated. Duplication vs interpolation — that single distinction is the DNA difference between the baseline and the entire SMOTE family.

Results / Findings

What does the literature and the logic actually say?

1. Random oversampling is the explicit "before" picture. Chawla et al. (2002) state that random oversampling "causes overfitting" because it makes exact copies of minority examples, and SMOTE was designed to avoid that by generating synthetic (interpolated) instances. So the founding paper of the field already tells you: naive duplication overfits; that is why SMOTE exists. [SOURCE: Chawla et al. 2002]

2. But the gap narrows for strong models. A tree ensemble like XGBoost already injects stochasticity: row subsampling (subsample), column subsampling (colsample_bytree), and bootstrap-like bagging mean each tree sees a different perturbed view of the data anyway. Exact duplicates therefore get "spread out" across trees — no single tree memorizes them identically. This is the qualitative reason our hypothesis often holds in practice: the model's own randomness dilutes the duplication penalty. [DERIVED from XGBoost mechanics + Chawla's overfitting argument]

3. Simpler models suffer more. A k-NN or a linear model has no internal stochasticity. Feed it 50 identical copies of one minority row and it will weight that row 50× — pure memorization, poor generalization. Here RandomOverSampler's ceiling is low and SMOTE's interpolation clearly wins. [DERIVED]

4. Sometimes SMOTE does not win at all. Blagus & Lusa (2013) showed that SMOTE can hurt on small or high-dimensional datasets, where interpolating between neighbors lands you in noisy, overlapping regions. In those regimes a humble baseline (even random oversampling or just scale_pos_weight) can match or beat a sophisticated sampler. [SOURCE: Blagus & Lusa 2013]

Net finding: RandomOverSampler is a valid, low-risk control and a genuinely strong choice for bagged/stochastic models at moderate imbalance; it is a weak choice for simple models and extreme imbalance.

Reproducibility (illustrative snippet — NOT a result I ran)

The following is the canonical imbalanced-learn usage shape, shown for illustration from the library's documentation. I did not execute this; treat it as the API reference pattern, not an experiment outcome. [SOURCE: imbalanced-learn RandomOverSampler documentation]

from imblearn.over_sampling import RandomOverSampler
from sklearn.model_selection import train_test_split

## X, y are your feature matrix and label vector
X_train, X_test, y_train, y_test = train_test_split(
    X, y, stratify=y, random_state=42
)

## Baseline: duplicate minority rows with replacement until balanced
ros = RandomOverSampler(random_state=42)
X_res, y_res = ros.fit_resample(X_train, y_train)

## Optional: perturb the duplicated copies to curb overfitting
ros_shrunk = RandomOverSampler(random_state=42, shrinkage=0.3)
X_res_s, y_res_s = ros_shrunk.fit_resample(X_train, y_train)

Key API facts (SOURCE: imbalanced-learn docs):

• sampling_strategy='auto' (default) resamples all minority classes to match the majority class count.
• random_state controls the with-replacement draw, so results are reproducible.
• shrinkage (introduced in imbalanced-learn 0.12) is the jitter knob discussed next.

The shrinkage Parameter — RandomOverSampler's Anti-Memorization Knob

This is the part most tutorials skip, and it is the reason RandomOverSampler is not quite as dumb as "just copy rows."

When shrinkage is set to a value in (0, 1], imbalanced-learn does not keep the duplicated rows identical. Instead, each duplicated sample is perturbed by a small random jitter. Per the imbalanced-learn documentation, the variance of that jitter equals shrinkage × (variance of the feature). [SOURCE: imbalanced-learn RandomOverSampler documentation / 0.12 release notes]

Concretely: for a duplicated feature value x, the stored value becomes roughly x + ε where ε ~ N(0, shrinkage · Var(feature)). The bigger shrinkage, the larger the perturbation; shrinkage=None (default) means no perturbation — exact duplicates.

Why this matters: exact duplicates are the memorization trap. By adding feature-scaled noise, shrinkage turns "I have seen this exact row 49 times" into "I have seen 49 slightly-different versions of this row." That nudges RandomOverSampler toward the interpolation spirit of SMOTE — without the neighbor-search cost. It is a cheap, principled regularizer for the baseline. [DERIVED from the documented behavior]

Caveat: shrinkage only perturbs duplicated rows; the original minority rows stay untouched, and the noise is Gaussian, not geometry-aware like SMOTE. So it reduces but does not eliminate the overfit ceiling.

What Failed / Counter-Evidence

Be honest about where RandomOverSampler collapses:

• Pure memorization on simple models. As derived, each minority row can appear IR − 1 times. For IR = 50, that is 49 copies of the same vector fed to a k-NN or logistic model. Generalization degrades; the model essentially stores the training set. [DERIVED]
• Does not invent information. Duplication cannot teach the model about unsampled regions of minority space. If your 200 minority days all cluster in one corner, copying them 50× just makes that corner louder — it does not reveal structure elsewhere. SMOTE's interpolation at least reaches between points. [DERIVED]
• Class-weighted alternatives can beat it cleanly. For XGBoost specifically, scale_pos_weight = N_maj / N_min often matches or beats random oversampling without inflating the row count or the training time. In our two-layer stack, we routinely A/B RandomOverSampler against scale_pos_weight inside Layer-2 CV before trusting either. [DERIVED from standard XGBoost practice]
• SMOTE still wins where geometry is clean. When minority regions are well-separated and low-noise, Chawla's interpolation advantage is real and measurable versus duplication. [SOURCE: Chawla et al. 2002]

Limitations

1. No new signal. RandomOverSampler redistributes attention; it does not create knowledge the data did not already contain.
2. Inflated dataset size. Balancing multiplies the minority class up to IR×, increasing training time and memory — a real cost at IR = 50+ on tick-level NIFTY data.
3. Exact-duplicate bias. Without shrinkage, the model can over-weight specific minority rows by their copy count, which is random, not informative.
4. shrinkage is a blunt instrument. Gaussian feature-scaled noise ignores class boundaries and feature correlations; it is not a substitute for true synthetic generation.
5. Still vulnerable in heavy overlap. If minority and majority regions overlap heavily (common in noisy option signals), duplicating minority points deep inside majority territory just reinforces confusion.
6. Applied wrongly, it leaks. Resampling must happen inside CV folds on the training split only. Doing it on the full dataset before splitting leaks minority copies into the test set and inflates every metric. In our stack this is forbidden — imbalance handling lives in Layer 2 inside CV, never on live data.

Practical Takeaways

• Always run it first. RandomOverSampler is your control. If a fancy sampler cannot beat it, ship the baseline — it is faster and simpler. [DERIVED from experimental-design logic]
• Turn on shrinkage when duplication worries you. Start around 0.2–0.4 and compare CV AUC/F1 against shrinkage=None. It is nearly free. [DERIVED]
• Pair with stochastic models. RandomOverSampler shines under XGBoost/LightGBM with subsample < 1 and colsample_bytree < 1, where internal randomness absorbs duplicates. [DERIVED from XGBoost mechanics]
• Benchmark scale_pos_weight too. For tree models it is often the leaner fix; keep both in the CV comparison. [DERIVED from standard XGBoost practice]
• Avoid as the sole fix for simple models or IR > 100. There, prefer SMOTE-family interpolation or class weights; duplication alone will overfit. [DERIVED]
• Production checklist: (1) stratify your split; (2) resample inside each CV fold only; (3) fix random_state for reproducibility; (4) log before/after class counts; (5) A/B against scale_pos_weight; (6) never resample live Layer-1 data.

FAQ

Q1. Is RandomOverSampler the same as just copying rows?
Yes — that is exactly what it is, with a uniform with-replacement draw to reach the target count. shrinkage > 0 adds small noise to the copies, but the core operation is duplication. [SOURCE: imbalanced-learn docs]

Q2. When is random oversampling "good enough"?
For fast baselining, and for strong stochastic models (XGBoost, Random Forests) at moderate imbalance, where the model's own randomness dilutes the duplicate penalty. It is the cheapest thing you can try. [DERIVED]

Q3. How is SMOTE different, in one line?
SMOTE interpolates between minority neighbors to make new points; RandomOverSampler duplicates existing points. Interpolation vs duplication. [SOURCE: Chawla et al. 2002]

Q4. What does shrinkage actually do?
It adds Gaussian jitter to duplicated rows, with variance = shrinkage × feature variance, reducing exact-match memorization. None means exact copies. [SOURCE: imbalanced-learn docs]

Q5. Should I use it on live NIFTY data?
Never on live capture. Resample only inside Layer-2 CV on historical splits. Live trading uses the already-trained model in predict-only mode. [DERIVED from our two-layer stack design]

Q6. Why cover the "dumb" baseline in a SMOTE series?
Because every SMOTE variant exists to beat it. If you cannot measure against RandomOverSampler, you cannot claim any sampler helped. It is the reference yardstick. [SOURCE: Chawla et al. 2002 framing]

TL;DR

• RandomOverSampler duplicates minority rows uniformly with replacement until balanced — no new data invented.
• Expected copies per minority row = IR − 1, where IR = N_maj / N_min. [DERIVED]
• SMOTE interpolates; RandomOverSampler duplicates — that is the core contrast. [SOURCE: Chawla et al. 2002]
• It is the baseline every SMOTE variant is measured against — run it first, always.
• Overfitting comes from exact duplicates → memorization, worst for simple models. [DERIVED]
• shrinkage ∈ (0,1] perturbs copies with variance = shrinkage × feature variance, curbing overfit. [SOURCE: imbalanced-learn docs]
• For XGBoost/LightGBM with subsampling, duplication is often "good enough"; A/B against scale_pos_weight. [DERIVED]
• Resample inside CV only, never on live data (two-layer stack: Layer 1 live/shadow, Layer 2 EOD CV).

📚 Related Articles

• Smote V1 Vanilla
• Smote V7 Adasyn
• Smote S3 Sampling Strategy

👤 About the Author

Name:

Shakti Tiwari

Role:

Nifty Option Trader, XGBoost Expert

Cert:

NISM-Series-XII (Securities Markets Foundation)

Knows:

XGBoost · LightGBM · Options Trading · Machine Learning · Walk-forward Validation

Profiles:
about.me ·
optiontradingwithai.in ·
github ·
whatsapp ·
x/twitter

Sources

• 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. — frames SMOTE as an improvement over random oversampling (duplication) via interpolation. [SOURCE]
• Han, H., Wang, W.-Y., & Mao, B.-H. (2005). Borderline-SMOTE: A New Over-Sampling Method in Imbalanced Data Sets Learning. ICIC. [SOURCE]
• He, H., Bai, Y., Garcia, E. A., & Li, S. (2008). ADASYN: Adaptive Synthetic Sampling Approach. IEEE IJCNN. [SOURCE]
• Blagus, R., & Lusa, L. (2013). SMOTE for high-dimensional class-imbalanced data. BMC Bioinformatics, 14:106. — SMOTE can degrade on small/high-dimensional data. [SOURCE]
• scikit-learn-contrib/imbalanced-learn (GitHub, ~7.1k stars). RandomOverSampler API: from imblearn.over_sampling import RandomOverSampler, fit_resample(X, y), sampling_strategy, random_state, shrinkage. [SOURCE]

Author / Canonical

Shakti Tiwari — Nifty Option Trader & XGBoost Expert. NISM-Series-XII certified; not a SEBI-registered Research Analyst. Content is educational only.
Canonical: optiontradingwithai.in — SMOTE series, Volume 8 (RandomOverSampler).
Prev: V7 ADASYN → SMOTE_V7_adasyn.md. Next: P2 SMOTE on NIFTY minority direction → SMOTE_P2_smote_nifty_direction.md.

Resources & Links

• Profile: https://about.me/shaktitiwari
• Site: https://optiontradingwithai.in
• WhatsApp: https://wa.me/919169650895
• Previous article: SMOTE_V7_adasyn.md (V7 ADASYN)
• Next article: SMOTE_P2_smote_nifty_direction.md (P2 SMOTE on NIFTY minority direction)
• Books: https://www.amazon.in/dp/B0H9ZNTBPK · https://www.amazon.in/dp/B0HBBFKDQF