Learn about overfitting and curve fitting — Stock-Market notes

What is Overfitting?

WHY it happens:

Too many parameters: A model with 50 tunable parameters can fit any dataset, even random noise
Insufficient data: 100 data points can't reliably estimate 20 parameters (rule of thumb: need10-20 observations per parameter)
Repeated testing: Running 100 backtests and picking the best one means you found the luckiest parameter set, not the best strategy
Ignoring regime changes: A model trained on 2010-2020 may fail in 2021 if market structure changed

The Mathematics of Overfitting

Bias-Variance Tradeoff

Every model's prediction error decomposes into three components:

$\text{Total Error} = \text{Bias}^2 + \text{Variance} + \text{Irreducible Error}$

Deriving from first principles:

Let's say the true relationship is $y = f(x) + \epsilon$ where $\epsilon$ is random noise with $E[\epsilon] = 0$ and $\text{Var}(\epsilon) = \sigma^2$ .

Our model predicts $\hat{f}(x)$ . The expected prediction error at a point $x_0$ is:

$E[(y - \hat{f}(x_0))^2]$

Step 1: Expand using $y = f(x_0) + \epsilon$ :

$E[(f(x_0) + \epsilon - \hat{f}(x_0))^2]$

Step 2: Rearrange and add/subtract $E[\hat{f}(x_0)]$ :

$E[((f(x_0) - E[\hat{f}(x_0)]) + (E[\hat{f}(x_0)] - \hat{f}(x_0)) + \epsilon)^2]$

Step 3: Expand the square (three terms, six cross products):

$E[(f(x_0) - E[\hat{f}(x_0)])^2] + E[(E[\hat{f}(x_0)] - \hat{f}(x_0))^2] + E[\epsilon^2] + \text{cross terms}$

WHY cross terms vanish:

$(f(x_0) - E[\hat{f}(x_0)])$ is a constant (no randomness)
$E[\epsilon] = 0$ by assumption
$E[\hat{f}(x_0)] - \hat{f}(x_0)$ has zero mean by definition of expectation

Step 4: Recognize the components:

$\underbrace{(f(x_0) - E[\hat{f}(x_0)])^2}_{\text{Bias}^2} + \underbrace{E[(\hat{f}(x_0) - E[\hat{f}(x_0)])^2]}_{\text{Variance}} + \underbrace{\sigma^2}_{\text{Irreducible}}$

Overfitting in Action: Polynomial Regression

Suppose we're predicting stock returns using a polynomial of degree $d$ :

$\hat{y} = \beta_0 + \beta_1 x + \beta_2 x^2 + \ldots + \beta_d x^d$

WHY this demonstrates overfitting: As $d$ increases, the model can fit training data perfectly, but test error explodes.

HOW to see it mathematically:

With $n$ data points and degree $d = n-1$ , the polynomial passes through every point exactly (Lagrange interpolation). Training error = 0, but between points, the polynomial oscillates wildly.

Degrees of freedom: The effective number of parameters. For polynomial degree $d$ , DoF = $d+1$ . Rule of thumb: need $n \geq 10 \times \text{DoF}$ for stable estimates.

Examples from Algorithmic Trading

Worked example Example 1: Moving Average Crossover Optimization

Setup: You're testing a MA crossover strategy with fast period $p_1$ and slow period $p_2$ . You try every combination where $p_1 \in [5, 50]$ and $p_2 \in [20, 200]$ in steps of 5. Calculation: Total combinations = $10\times 37 = 370$ backtests

Result: The best one shows Sharpe ratio 2.5 on2018-2022 data. You trade it live in 2023 and get Sharpe 0.3

WHY this failed:

Multiple testing: With 370 trials, even random data will produce some "good" results by luck
No correction: You didn't apply Bonferroni correction (divide significance level by 370) or hold out validation data
Statistical reasoning: If each test has 5% chance of false positive, testing 370 times gives $1 - (0.95)^{370} \approx 99.999\%$ chance of finding at least one false positive The fix:

Use walk-forward analysis (train on 2018-2020, test on 2021, retrain on 2018-2021, test on 2022)
Limit parameter space using theoretical reasoning (e.g., "slow MA should be 3-5x fast MA")
Demand statistical significance with multiple testing correction

Worked example Example 2: Machine Learning Model with100 Features

Setup: You're predicting next-day stock returns using 100 technical indicators on 500 days of data.

Model: Random forest with 50 trees, min_samples_split = 2(allows very deep trees)

Result: Training R² = 0.92, Test R² = 0.08

WHY this is overfitting: Step 1: Calculate observations per parameter

With 100 features and deep trees, you effectively have hundreds of decision rules
500 days / 100+ parameters< 5 observations per parameter (danger zone) Step 2: Understand what the model learned
Deep trees memorize: "When RSI = 34.27 AND volume = 1.43M on Tuesday, return = +0.3%"
These exact conditions never repeat → fails on new data Step 3: The fix
Feature selection: Use domain knowledge + regularization to keep only 10-20 most informative features
Increase min_samples_split to 20+ (prevents overly specific rules)
Use cross-validation: 5-fold CV gives5 different train/test splits, harder to overfit all of them
Add regularization: L1 (Lasso) or L2 (Ridge) penalties that punish large coefficients

Worked example Example 3: The "Profitable by Luck" Strategy

Setup: You discover a strategy that buys when the S&P 500's 14-day RSI crosses above 30 on days when the VIX is above 20AND it's not a Friday. Backtest Sharpe: 3.2.

WHY this is suspect: Calculation of data snooping:

You probably tested dozens of variations: different RSI periods (10, 12, 14, 16), different thresholds (25, 30, 35), different VIX levels (15, 20, 25)
With/without the "not Friday" filter
Total tests≈ 4 × 3 × 3 2 = 72 variations

Statistical check:

Expected Sharpe from random data: $E[S] \approx 0$ , but $\text{Std}(S) \approx 1/\sqrt{T}$ where $T$ = number of periods
With $T = 252$ trading days, $\text{Std}(S) = 1/\sqrt{252} \approx 0.063$
Finding Sharpe 3.2 from 72 trials: $P(\max(S) > 3.2) \approx 72 \times P(S > 3.2)$ (Bonferroni bound)
Even if each trial is independent random noise, some will look amazing

The fix: Demand out-of-sample confirmation. Split data into 3 periods:

Training (2010-2015): Develop and optimize strategy
Validation (2016-2018): Test and tune
Test (2019-2022): Never touched until final evaluation

Only trust performance on the test set you never touched during development.

Common Mistakes and How to Avoid Them

Common mistake Mistake 1: "More data always prevents overfitting"

Why this feels right: Intuitively, having 10 years of data sounds safer than 1 year.

Why it's wrong:

Markets have regime changes. Data from 2008(financial crisis) has different properties than 2021 (low rates, meme stocks)
Old data may be non-stationary—the underlying process changed
More stale data ≠ more relevant information.1 year of current regime beats 10 years spanning multiple regimes.

The fix:

Use data from homogeneous regimes. Identify structural breaks (e.g., 2020 COVID, 2008 crisis) and don't train across them blindly.
Weight recent data more heavily (exponential decay)
Test strategy stability: Does it work in2015-2017? 2018-2020? 2021-2023 separately? If it only works in one period, it's likely overfit to that regime.

How to Detect and Prevent Overfitting

Detection Methods

Train/Test Split: $\text{Overfitting Score} = \frac{\text{Train Performance} - \text{Test Performance}}{\text{Train Performance}}$

If this ratio > 0.2 (20% degradation), likely overfit.
Cross-Validation:
- K-Fold: Split data into K chunks, train on K-1, test on 1, repeat K times
- Time-series CV: Use expanding or sliding window (preserve temporal order) WHY this works: Harder to overfit K different test sets simultaneously. High variance across folds = model unstable.
Learning Curves:
- Plot training error and validation error vs. training set size
- Converging curves (small gap at large N): Good generalization
- Diverging curves (widening gap): Overfitting
HOW to interpret: If adding more data closes the gap, collect more data. If gap persists, simplify model.
Permutation Test:
- Randomly shuffle target variable (destroy any real relationship)
- Re-run entire optimization process
- If "optimized" strategy on shuffled data still looks good, your process is curve-fitting noise
WHY this is powerful: Random data has no signal. Any found edge = false positive from your methodology.

Prevention Strategies

Formula Regularization

Add penalty term to loss function to discourage complexity:

L1 (Lasso): $\min_{\beta} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 + \lambda \sum_{j=1}^{p} |\beta_j|$

L2 (Ridge): $\min_{\beta} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 + \lambda \sum_{j=1}^{p} \beta_j^2$

Parameter $\lambda$ : Controls tradeoff between fit and simplicity

$\lambda = 0$ : No penalty, risk overfitting
$\lambda \to \infty$ : Maximum penalty, model becomes too simple (underfits) WHY L1 vs L2:
L1 forces some coefficients exactly to zero → feature selection
L2 shrinks all coefficients but keeps them all → smother fit

Practical Prevention Checklist:

Simplicity first: Start with simple model (linear regression, 2-3 features). Only add complexity if justified by theory and out-of-sample improvement.
Feature engineering over feature dumping: 5 carefully chosen features beat 100 raw indicators.
Economic reasoning: Every parameter should have a financial explanation. "Buy when 23-day MA crosses 47-day MA" has no theoretical basis—why not 22 and 46?
Walk-forward analysis:
- Train on Year 1, test on Year 2
- Retrain on Year 1-2, test on Year 3
- Continue rolling forward
- WHY: Simulates real trading where you periodically retrain with new data
Robust optimization: Instead of picking the single best parameter set, choose one that performs well enough across a range of nearby parameters. If performance is sensitive to small changes (e.g., MA period 14 vs. 15 completely changes results), strategy is fragile.
Information coefficient (IC): For predictive models, measure rank correlation between predictions and actual outcomes: $\text{IC} = \text{cor}(\text{predicted returns}, \text{actual returns})$

IC should be stable across time periods. Declining IC = strategy decay or overfitting.
Sample size rules:
- Minimum: $n > 10p$ where $p$ = number of parameters
- Conservative: $n > 30p$
- For rare events (e.g., predicting crashes): Need hundreds of occurrences

Recall Explain to a 12-year-old

Imagine you're learning to recognize your friend's handwriting. Your friend shows you 20 words they wrote. You could memorize exactly how they wrote those 20 specific words—every little wigle and dot. But that's silly! Because next time they write "hello," it won't look exactly the same. Maybe the'e' will be slightly rounder. If you memorized too perfectly, you won't recognize it.

The smart way is to learn the general style: "Oh, they make their 'h' taller than normal and connect their letters smoothly." Now you can recognize their handwriting even in new words you've never seen them write before.

In stock trading, overfitting is like memorizing those exact20 words instead of learning the general style. Your computer strategy looks at old stock prices and learns "On June 5th 2018 when price was exactly $34.27, it went up!" But that exact situation will never happen again. The strategy fails on new data because it memorized history's details instead of learning real patterns.

The fix? Keep your strategy simple. Test it on data your computer has never seen before (like surprise quiz!). And always ask "Why would this work?" not just "Did this work in the past?"

Mathematical Rigor: Degrees of Freedom

The effective degrees of freedom of a model is the number of independent parameters being estimated. For trading strategies:

$\text{DoF} = \text{\# explicit parameters} + \text{\# implicit choices}$

Explicit: MA periods, threshold values, position sizes Implicit: Which features to include, which optimization metric to use, when to start/stop backtest

WHY this matters: Statistical tests assume degrees of freedom. If you claim "My strategy has t-statistic of 3.5, significant at p< 0.001," but you secretly tried 100 variations, the actual p-value is much higher.

Bonferroni correction: If you run $m$ independent tests, adjust significance level:

$\alpha_{\text{corrected}} = \frac{\alpha}{m}$

If you want overall5% significance and run 100 tests: $\alpha_{\text{corrected}} = 0.05 / 100 = 0.005$ . Now you need t-statistic of ~3.5 instead of 1.96.

Connections

6.1.8-Backtesting-strategies-and-interpreting-results - Overfitting makes backtest results unreliable
6.1.9-Walk-forward-analysis-and-out-of-sample-testing - Primary defense against overfitting
6.21-What-is-quantitative-trading - Quant models are especially vulnerable to overfitting
5.3.5-Risk-management-in-algorithmic-trading - Overfit models have higher real-world risk than backtest suggests
6.1.3-Types-of-algorithmic-strategies - All strategy types must guard against overfitting
4.4-Standard-deviation-and-variance - Understanding variance is key to bias-variance tradeoff
Machine-learning-in-trading - ML models have high capacity, require strong overfitting prevention

#flashcards/stock-market

What is overfitting in trading? :: When a model learns noise and random fluctuations in historical data rather than true signal, resulting in good backtest performance but poor live performance.

What is the bias-variance tradeoff?

Total error = Bias² + Variance + Irreducible error. Complex models have low bias but high variance; simple models have high bias but low variance. Must balance.

Why does multiple testing cause overfitting?

Testing many parameter combinations means some will look good by pure luck. With 100 tests at 5% significance, probability of at least one false positive approaches 100%.

What is walk-forward analysis?

Train on Period 1, test on Period 2, retrain on Period 1-2, test on Period 3, rolling forward. Simulates real trading with periodic retraining and prevents using future information.

What is the rule of thumb for sample size vs parameters?

Need minimum n > 10p observations, where p is number of parameters. Conservative standard is n > 30p. For rare events need hundreds of occurrences.

What is curve fitting?

Repeatedly adjusting model parameters while looking at test results until performance looks good. Contaminates the test set because you're using information from it to guide development.

What is regularization?

Adding penalty term to loss function to discourage model complexity. L1 (Lasso) forces some coefficients to zero for feature selection. L2 (Ridge) shrinks all coefficients for smoother fit.

How do you detect overfitting? :: Compare train vs test performance (>20% degradation is warning), use k-fold cross-validation (high variance across folds), plot learning curves (diverging curves), run permutation tests on shuffled data.

What is the permutation test for overfitting?

Randomly shuffle the target variable to destroy real relationships, then re-run entire optimization. If results still look good on random data, your process curve-fits noise.

Why doesn't more data always prevent overfitting? :: Markets have regime changes and non-stationarity. Old data from different regimes may hurt more than help. 1 year of current regime data beats 10 years spanning multiple different regimes.

What is the Bonferroni correction?

When running m independent tests, adjust significance level to α/m. If testing 100 parameter combinations at 5% overall significance, each individual test needs0.05/100 = 0.0005 significance.

What are effective degrees of freedom?

Total count of both explicit parameters (MA periods, thresholds) and implicit choices (which features to test, which metric to optimize, date range selection). All count toward multiple testing problem.

What is robust optimization?

Choosing parameter sets that perform well enough across a range of nearby values rather than the single best. If small parameter changes dramatically alter results, strategy is fragile and overfit.

What is information coefficient?

Rank correlation between predicted returns and actual returns: IC = corr(predictions, outcomes). Should remain stable across time periods. Declining IC indicates strategy decay or overfitting.

What makes a model parsimonious?

Using the simplest model that adequately explains the data. Each parameter must have economic justification. Prefer3 theoretically-motivated features over 50 data-mined indicators.

Concept Map

Hinglish (regional understanding)

Intuition Hinglish mein samjho

Dekho, is note ka core idea simple hai lekin bahut important hai. Overfitting ka matlab hai ki tumhara trading model historical data ki har chhoti-chhoti cheez, yahan tak ki random noise aur coincidences ko bhi "yaad" kar leta hai — bilkul waise jaise koi student practice questions ko word-for-word ratta maar leta hai, typos ke saath. Aisa model backtest mein 95% accuracy dikhayega, but jab real market mein live trading karoge toh paisa gawaoge, kyunki usne asli repeatable pattern nahi seekha, sirf past ke luck ko fit kiya hai. Market kabhi exactly repeat nahi hoti — woh sirf "rhyme" karti hai.

Ab why-it-matters wali baat: iske peeche jo maths hai woh hai bias-variance tradeoff. Total error ke teen parts hote hain — bias square, variance, aur irreducible noise. Simple model ka bias zyada hota hai (galat assumptions), par variance kam. Complex model (jaise high-degree polynomial ya 50 parameters wala model) ka bias kam hota hai kyunki woh kisi bhi shape ko fit kar sakta hai, lekin variance bahut high — matlab thoda sa data change karo aur model ka behaviour poori tarah badal jaata hai. Yehi instability live market mein loss ka reason banti hai. Agar tumhare paas sirf 100 data points hain aur tum 20 parameters estimate kar rahe ho, toh model noise ko hi signal samajh lega.

Practical takeaway ye hai ki jab bhi strategy banao, dhyan rakho: zyada parameters mat use karo, enough data rakho (rule of thumb 10-20 observations per parameter), aur baar-baar backtest chala kar "best" strategy mat chuno — kyunki 100 backtests mein se best pick karna matlab tumne sabse lucky parameter set dhoondha, sabse achhi strategy nahi. Isliye out-of-sample testing bahut zaroori hai — model ko naye, unseen data par check karo, tabhi pata chalega ki usme real edge hai ya sirf curve fitting.

Test yourself — Algorithmic & Quant Trading

Connections