Time Series Analysis: Zero to Hero Study Guide

Table of Contents
1. Foundations & Core Concepts
2. Time Series Components

3. Stationarity & Testing

4. Classical Models (ARIMA Family)

5. Advanced Statistical Models

6. Machine Learning Approaches

7. Deep Learning with TensorFlow

8. Real-World Applications

9. Portfolio Optimization Bridge

10. Common Pitfalls & Solutions

1. Foundations & Core Concepts {#foundations}

What is Time Series Analysis?

Definition: Analysis of data points collected sequentially over time, where the order matters crucially.

Real-World Analogy: Think of a time series like a patient's medical chart. Each measurement (blood
pressure, weight, temperature) is meaningless without knowing WHEN it was taken. The sequence tells
the story of health progression.

Key Characteristics
Temporal Dependency: Past values influence future values
Sequential Order: Data points have inherent ordering

Trend: Long-term direction (like a river's general flow)

Seasonality: Repeating patterns (like tides)
Noise: Random fluctuations (like ripples on water)

Types of Time Series Data

1. Univariate: Single variable over time (stock price)
2. Multivariate: Multiple variables over time (stock price + volume + economic indicators)
 3. Regular: Fixed intervals (daily, monthly)
4. Irregular: Variable intervals (earthquake occurrences)

Mathematical Notation
Y(t): Value at time t
Δt: Time interval

T: Total time periods

n: Number of observations

2. Time Series Components {#components}

The Four Pillars

Time series = Trend + Seasonality + Cyclical + Irregular (Noise)

Analogy: Think of a city's population growth:

Trend: Overall population increase over decades

Seasonal: Summer tourist influx, winter exodus

Cyclical: Economic boom/bust cycles affecting migration

Irregular: Random events (natural disasters, policy changes)

Decomposition Methods

Additive Model

Y(t) = Trend(t) + Seasonal(t) + Cyclical(t) + Error(t)

When to use: When seasonal fluctuations are constant over time Example: Temperature variations in a
stable climate

Multiplicative Model

Y(t) = Trend(t) × Seasonal(t) × Cyclical(t) × Error(t)

When to use: When seasonal effects grow with the trend Example: Retail sales (Christmas sales grow as
company expands)

Practical Implementation Notes

 python

# Key libraries for decomposition

from statsmodels.tsa.seasonal import seasonal_decompose
import pandas as pd

# Basic decomposition
decomposition = seasonal_decompose(data, model='additive', period=12)

3. Stationarity & Testing {#stationarity}

Understanding Stationarity
Definition: A time series is stationary if its statistical properties don't change over time.

River Analogy:

Stationary: A river with consistent flow rate, depth, and width

Non-stationary: A river during monsoon season with changing characteristics

Types of Stationarity

Strict Stationarity

All statistical properties remain constant over time. Analogy: A perfectly controlled laboratory
environment

Weak Stationarity (Most Practical)

1. Constant Mean: μ(t) = μ for all t

2. Constant Variance: σ²(t) = σ² for all t

3. Covariance depends only on lag: Cov(Y(t), Y(t+k)) = γ(k)

Testing for Stationarity

Visual Methods

1. Time Plot: Look for trends, changing variance

2. Rolling Statistics: Plot moving average and standard deviation

3. ACF/PACF Plots: Check for slow decay (indicates non-stationarity)

Statistical Tests
Augmented Dickey-Fuller (ADF) Test

Null Hypothesis: Series has unit root (non-stationary) Alternative: Series is stationary

Interpretation:

p-value < 0.05: Reject null → Series is stationary

p-value > 0.05: Fail to reject → Series is non-stationary

KPSS Test

Null Hypothesis: Series is stationary Alternative: Series has unit root

Pro Tip: Use both ADF and KPSS for confirmation:

ADF rejects + KPSS accepts → Stationary

ADF accepts + KPSS rejects → Non-stationary

Both reject → Difference-stationary

Both accept → Inconclusive (need more data)

Making Data Stationary

1. Differencing

First Difference: ΔY(t) = Y(t) - Y(t-1)

Second Difference: Δ²Y(t) = ΔY(t) - ΔY(t-1)

When to use: For trending data Analogy: Instead of measuring total rainfall, measure daily change in
rainfall

2. Log Transformation

Log Y(t) = ln(Y(t))

When to use: For exponential growth, stabilizing variance Example: Stock prices often need log
transformation

3. Detrending

Linear Detrending: Remove linear trend

Polynomial Detrending: Remove polynomial trend

4. Seasonal Differencing
 Seasonal Difference: Y(t) - Y(t-s)
where s = seasonal period

4. Classical Models (ARIMA Family) {#classical-models}

The Building Blocks

AutoRegressive (AR) Models

Concept: Current value depends on previous values Formula: Y(t) = φ₁Y(t-1) + φ₂Y(t-2) + ... + φₚY(t-p) +
ε(t)

Real-World Analogy: Your mood today depends on your mood yesterday and the day before. If you
were happy yesterday, you're more likely to be happy today.

AR(1) Example: Stock price momentum AR(2) Example: Economic indicators with quarterly
dependencies

Moving Average (MA) Models

Concept: Current value depends on current and past error terms Formula: Y(t) = ε(t) + θ₁ε(t-1) + θ₂ε(t-2)
+ ... + θₑε(t-q)

Real-World Analogy: Your performance today depends on recent unexpected events (errors/shocks) and
how they affected you.

ARMA Models

Formula: AR + MA combined

Y(t) = φ₁Y(t-1) + ... + φₚY(t-p) + ε(t) + θ₁ε(t-1) + ... + θₑε(t-q)

ARIMA Models
Full Name: AutoRegressive Integrated Moving Average Notation: ARIMA(p, d, q)

p: Order of autoregression

d: Degree of differencing

q: Order of moving average

Model Selection Process

Step 1: Make Data Stationary

Check stationarity (ADF, KPSS tests)

Apply differencing if needed

Determine 'd' parameter

Step 2: Identify p and q

Method 1: ACF/PACF Analysis

PACF cuts off at lag p → AR(p) model

ACF cuts off at lag q → MA(q) model

Both decay gradually → ARMA model needed

Method 2: Information Criteria

AIC (Akaike Information Criterion): Penalizes complexity

BIC (Bayesian Information Criterion): More conservative

Lower values indicate better models

Step 3: Model Estimation

Use Maximum Likelihood Estimation (MLE) or Least Squares

Step 4: Diagnostic Checking

Residual Analysis: Should be white noise

Ljung-Box Test: Test for remaining autocorrelation

Normality Tests: QQ-plots, Shapiro-Wilk test

Seasonal ARIMA (SARIMA)

Notation: ARIMA(p,d,q)(P,D,Q)ₛ

Components:

(p,d,q): Non-seasonal part

(P,D,Q): Seasonal part

s: Seasonal period (12 for monthly, 4 for quarterly)

Example: ARIMA(1,1,1)(1,1,1)₁₂ for monthly sales data

Practical Implementation Guidelines

Parameter Ranges

Start Simple: Begin with ARIMA(1,1,1)

Maximum p,q: Usually ≤ 5 (computational efficiency)

Seasonal parameters: Usually ≤ 2

Code Template

python

from statsmodels.tsa.arima.model import ARIMA

import itertools

# Grid search for best parameters

p_values = range(0, 3)
d_values = range(0, 2)
q_values = range(0, 3)

best_aic = float('inf')
best_params = None

for p, d, q in itertools.product(p_values, d_values, q_values):

try:
model = ARIMA(data, order=(p, d, q))
fitted_model = model.fit()
if fitted_model.aic < best_aic:
best_aic = fitted_model.aic
best_params = (p, d, q)
except:
continue

5. Advanced Statistical Models {#advanced-models}

Vector Autoregression (VAR)

Purpose: Analyze multiple time series simultaneously Use Case: When variables influence each other

Stock Market Example:

Stock prices influence each other

Economic indicators affect multiple stocks

Volume affects price and vice versa
Mathematical Form:

Y₁(t) = α₁ + Σβ₁ᵢY₁(t-i) + Σγ₁ᵢY₂(t-i) + ε₁(t)

Y₂(t) = α₂ + Σβ₂ᵢY₁(t-i) + Σγ₂ᵢY₂(t-i) + ε₂(t)

Vector Error Correction Model (VECM)

Purpose: Handle cointegrated non-stationary series Key Insight: Even if individual series are non-
stationary, their linear combination might be stationary

Real-World Analogy: Two drunk people walking home together. Individually, they're erratic (non-
stationary), but they stay close to each other (cointegrated).

GARCH Models
Full Name: Generalized AutoRegressive Conditional Heteroskedasticity Purpose: Model time-varying
volatility

Financial Application: Stock return volatility clusters

High volatility periods followed by high volatility

Low volatility periods followed by low volatility

GARCH(1,1) Formula:

σ²(t) = ω + α₁ε²(t-1) + β₁σ²(t-1)

State Space Models

Concept: Separate observed data from underlying state Components:

State Equation: How true state evolves

Observation Equation: How we observe the state

Kalman Filter Application: GPS tracking with noise

6. Machine Learning Approaches {#ml-approaches}

When to Choose ML Over Classical Methods

Classical Methods Excel When:

Strong theoretical understanding of the process

 Clear seasonal patterns

Limited data

Interpretability is crucial

Linear relationships dominate

ML Methods Excel When:

Complex non-linear relationships

Multiple external factors

Large datasets available

Prediction accuracy is priority

Pattern complexity exceeds human understanding

Supervised Learning for Time Series

Feature Engineering Strategies

1. Lag Features

python

# Create lag features

df['lag_1'] = df['value'].shift(1)
df['lag_2'] = df['value'].shift(2)
df['lag_7'] = df['value'].shift(7) # Weekly pattern

2. Rolling Window Features

python

# Rolling statistics
df['rolling_mean_7'] = df['value'].rolling(window=7).mean()
df['rolling_std_7'] = df['value'].rolling(window=7).std()
df['rolling_min_7'] = df['value'].rolling(window=7).min()
df['rolling_max_7'] = df['value'].rolling(window=7).max()

3. Time-based Features
 python

# Extract time components

df['hour'] = df.index.hour
df['day_of_week'] = df.index.dayofweek
df['month'] = df.index.month
df['is_weekend'] = df.index.dayofweek.isin([5, 6])

4. Technical Indicators (Finance)

python

# Moving averages
df['ma_short'] = df['price'].rolling(20).mean()
df['ma_long'] = df['price'].rolling(50).mean()
df['ma_ratio'] = df['ma_short'] / df['ma_long']

# Volatility
df['volatility'] = df['returns'].rolling(20).std()

Popular ML Algorithms

Random Forest for Time Series

Advantages:

Handles non-linear relationships

Built-in feature importance

Robust to outliers
No assumption about data distribution

Considerations:

Can overfit with too many features

Doesn't naturally handle temporal dependencies

Need careful cross-validation

Gradient Boosting (XGBoost, LightGBM)

Strengths:

Excellent performance on tabular data

Handles missing values

 Built-in regularization
Feature importance ranking

Time Series Specific Tips:

Use time-based splits for validation

Consider monotonic constraints for trend features

Tune learning rate carefully

Support Vector Regression (SVR)

Best For:

Non-linear patterns with kernel tricks

Small to medium datasets

When you need confidence intervals

Cross-Validation for Time Series

Time Series Split

python

from sklearn.model_selection import TimeSeriesSplit

tscv = TimeSeriesSplit(n_splits=5)
for train_idx, test_idx in tscv.split(X):
X_train, X_test = X[train_idx], X[test_idx]
y_train, y_test = y[train_idx], y[test_idx]
# Train and evaluate model

Walk-Forward Validation

Train on historical data

Predict next period
Add actual value to training set

Repeat

Analogy: Like studying for an exam by taking practice tests in chronological order, learning from each
before the next.
7. Deep Learning with TensorFlow {#deep-learning}

Why Deep Learning for Time Series?

Advantages:

Automatic Feature Learning: No manual feature engineering

Non-linear Pattern Recognition: Complex relationship modeling

Multi-scale Pattern Capture: From short-term to long-term dependencies

Multivariate Handling: Natural handling of multiple input series

Challenges:

Data Requirements: Need large datasets

Computational Cost: Resource intensive

Black Box: Less interpretable

Overfitting Risk: Especially with small datasets

Neural Network Architectures

1. Multi-Layer Perceptron (MLP)

Use Case: Simple non-linear relationships with engineered features

python

import tensorflow as tf

def create_mlp_model(input_shape):
model = tf.keras.Sequential([
tf.keras.layers.Dense(64, activation='relu', input_shape=input_shape),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(32, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse', metrics=['mae'])

return model

2. Recurrent Neural Networks (RNN)

Simple RNN
Problem: Vanishing gradient problem Use Case: Very short sequences only

Long Short-Term Memory (LSTM)

Strength: Handles long-term dependencies Architecture Components:

Forget Gate: What to forget from cell state

Input Gate: What new information to store

Output Gate: What to output based on cell state

Analogy: LSTM is like a smart notebook that decides:

What old notes to erase (forget gate)

What new information to write down (input gate)

What information to share with others (output gate)

python

def create_lstm_model(sequence_length, n_features):

model = tf.keras.Sequential([
tf.keras.layers.LSTM(50, return_sequences=True,
input_shape=(sequence_length, n_features)),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.LSTM(50, return_sequences=False),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(25),
tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')
return model

Gated Recurrent Unit (GRU)

Advantage: Simpler than LSTM, often similar performance When to use: When computational efficiency
matters

3. Convolutional Neural Networks (CNN)

Use Case: Pattern recognition in time series Advantage: Captures local patterns efficiently
 python

def create_cnn_model(sequence_length, n_features):

model = tf.keras.Sequential([
tf.keras.layers.Conv1D(filters=64, kernel_size=3,
activation='relu',
input_shape=(sequence_length, n_features)),
tf.keras.layers.Conv1D(filters=64, kernel_size=3, activation='relu'),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.MaxPooling1D(pool_size=2),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(50, activation='relu'),
tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')
return model

4. Hybrid Models (CNN-LSTM)

Concept: CNN for feature extraction + LSTM for sequence modeling

python

def create_cnn_lstm_model(sequence_length, n_features):

model = tf.keras.Sequential([
tf.keras.layers.Conv1D(filters=64, kernel_size=3,
activation='relu',
input_shape=(sequence_length, n_features)),
tf.keras.layers.Conv1D(filters=64, kernel_size=3, activation='relu'),
tf.keras.layers.MaxPooling1D(pool_size=2),
tf.keras.layers.LSTM(50),
tf.keras.layers.Dropout(0.5),
tf.keras.layers.Dense(1)
])

model.compile(optimizer='adam', loss='mse')
return model

Advanced Architectures

Transformer Models
Key Innovation: Attention mechanism Advantage: Parallel processing, long-range dependencies Use
Case: Complex multivariate time series

Sequence-to-Sequence (Seq2Seq)

Use Case: Multi-step forecasting Components: Encoder-Decoder architecture

Data Preparation for Deep Learning

Creating Sequences

python

def create_sequences(data, seq_length):

X, y = [], []
for i in range(len(data) - seq_length):
X.append(data[i:(i + seq_length)])
y.append(data[i + seq_length])
return np.array(X), np.array(y)

# Example usage
seq_length = 60 # Use 60 previous time steps
X, y = create_sequences(scaled_data, seq_length)

Scaling and Normalization

python

from sklearn.preprocessing import MinMaxScaler

scaler = MinMaxScaler(feature_range=(0, 1))

scaled_data = scaler.fit_transform(data.reshape(-1, 1))

# Important: Save scaler for inverse transformation

# predictions_original = scaler.inverse_transform(predictions)

Training Best Practices

Early Stopping
 python

early_stopping = tf.keras.callbacks.EarlyStopping(
monitor='val_loss',
patience=10,
restore_best_weights=True
)

Learning Rate Scheduling

python

lr_scheduler = tf.keras.callbacks.ReduceLROnPlateau(
monitor='val_loss',
factor=0.5,
patience=5,
min_lr=1e-7
)

Model Checkpointing

python

checkpoint = tf.keras.callbacks.ModelCheckpoint(
'best_model.h5',
monitor='val_loss',
save_best_only=True
)

8. Real-World Applications {#applications}

Financial Time Series

Stock Price Prediction

Challenges:

High noise-to-signal ratio

Market efficiency hypothesis

Regime changes

External shocks
Feature Engineering:

Technical indicators (RSI, MACD, Bollinger Bands)

Volume-price relationships

Market sentiment indicators

Macroeconomic variables

Model Selection Strategy:

1. Short-term (intraday): LSTM/GRU for pattern recognition

2. Medium-term (days to weeks): Ensemble of classical + ML

3. Long-term (months): Focus on fundamental analysis integration

Volatility Forecasting

Importance: Risk management, option pricing Models: GARCH family, stochastic volatility models Key
Insight: Volatility is more predictable than returns

Economic Forecasting

GDP Growth Prediction

Data Sources:

Leading indicators (employment, manufacturing)

Lagging indicators (inflation, interest rates)

Coincident indicators (industrial production)

Modeling Approach:

VAR models for multi-indicator analysis

Factor models for dimension reduction
Regime-switching models for business cycles

Inflation Forecasting

Phillips Curve Integration: Unemployment vs inflation relationship Modern Approaches: Include

expectations, global factors

Demand Forecasting

Retail Sales Prediction

Seasonality Layers:

Weekly patterns (weekends vs weekdays)

Monthly patterns (payday effects)

Annual patterns (holidays, seasons)

External Factors:

Weather data
Economic indicators

Marketing campaigns

Competitor actions

Hierarchy Reconciliation: Ensure sub-category forecasts sum to total

Energy Demand Forecasting

Unique Characteristics:

Strong temperature dependency

Day-of-week effects
Holiday effects

Economic activity correlation

Modeling Strategy:

Weather-adjusted models

Multiple seasonality handling

Peak demand focus for capacity planning

Healthcare Applications

Epidemic Modeling

SIR Models: Susceptible-Infected-Recovered dynamics Data Challenges: Reporting delays, changing

testing rates Model Extensions: SEIR (Exposed), spatial components

Patient Monitoring

ICU Applications: Vital sign prediction, early warning systems Challenges: Missing data, patient
heterogeneity Solutions: Kalman filters for missing data interpolation
Climate and Environmental

Weather Forecasting

Numerical Weather Prediction: Physics-based models ML Enhancement: Post-processing, ensemble

methods Chaos Theory: Butterfly effect limits predictability

Climate Change Analysis

Trend Detection: Separating climate from weather Attribution Studies: Human vs natural factors
Projection Uncertainties: Model ensembles, scenario planning

IoT and Sensor Data

Predictive Maintenance

Objective: Predict equipment failure before it happens Data Types: Vibration, temperature, pressure,
current Approaches:

Anomaly detection

Remaining useful life prediction

Threshold-based alerts

ROI Calculation: Maintenance cost vs downtime cost

Smart Grid Management

Load Forecasting: Balance supply and demand Price Prediction: Real-time pricing optimization
Renewable Integration: Handle intermittent sources

9. Portfolio Optimization Bridge {#portfolio-optimization}

Time Series in Portfolio Management

Risk-Return Framework

Modern Portfolio Theory: Markowitz optimization Key Input: Covariance matrix of returns Time Series
Role: Estimate expected returns and covariances

Return Prediction Models

 python

# Simple return calculation

returns = (prices / prices.shift(1)) - 1

# Log returns (more statistically convenient)

log_returns = np.log(prices / prices.shift(1))

Volatility Modeling

Historical Volatility:

python

rolling_vol = returns.rolling(window=30).std() * np.sqrt(252)

GARCH Volatility:

Better for risk management

Captures volatility clustering

Forward-looking estimates

Correlation Dynamics

DCC-GARCH: Dynamic Conditional Correlation Use Case: Capture changing correlations during market
stress

Portfolio Construction Process

Step 1: Universe Selection

Screening Criteria:

Liquidity requirements
Market capitalization

Sector/geography constraints
ESG factors

Step 2: Expected Return Estimation

Approaches:

1. Historical Average: Simple but naive

 2. Factor Models: CAPM, Fama-French
3. Time Series Models: ARIMA, ML predictions

4. Analyst Forecasts: Forward-looking but biased

Step 3: Risk Modeling

Covariance Matrix Estimation:

Sample Covariance: Historical estimates

Factor Models: Reduce dimensionality

Shrinkage Methods: Ledoit-Wolf estimator

Dynamic Models: Time-varying covariances

Step 4: Optimization Engine

Mean-Variance Optimization:

max w'μ - (λ/2)w'Σw

subject to: Σw = 1, w ≥ 0 (if long-only)

Alternative Approaches:

Risk Parity: Equal risk contribution

Black-Litterman: Incorporate views
Robust Optimization: Account for estimation error

Risk Management Integration

Value at Risk (VaR)

Parametric VaR: Assume normal returns Historical VaR: Use empirical distribution Monte Carlo VaR:
Simulation-based

Time Series Input: Return distribution parameters

Expected Shortfall (ES)

Definition: Expected loss beyond VaR Advantage: Coherent risk measure Calculation: Requires return
distribution tail

Stress Testing
Historical Scenarios: 2008 crisis, COVID-19 Hypothetical Scenarios: Factor shock tests Monte Carlo:
Simulate extreme events

Performance Attribution

Factor Decomposition

Fama-French Factors: Market, size, value Time Series Regression:

r_portfolio = α + β₁*r_market + β₂*SMB + β₃*HML + ε

Rolling Analysis

Performance Metrics:

Sharpe ratio evolution

Maximum drawdown periods

Beta stability

Alternative Risk Premia

Momentum Strategy

Time Series Momentum: Asset's own past performance Cross-Sectional Momentum: Relative
performance ranking

Implementation:

python

# 12-1 month momentum

momentum_signal = (prices.shift(21) / prices.shift(252)) - 1

Mean Reversion

Statistical Arbitrage: Pairs trading Ornstein-Uhlenbeck Process: Mean-reverting model

Volatility Risk Premium

VIX Trading: Volatility surface dynamics Volatility Carry: Realized vs implied volatility

High-Frequency Considerations

Microstructure Noise
Bid-Ask Bounce: Price jumps between bid/ask Solution: Tick-time sampling, signature plots

Market Making Models

Inventory Risk: Position management Adverse Selection: Information asymmetry

Regime Detection

Hidden Markov Models

States: Bull market, bear market, sideways Transition Probabilities: State switching dynamics

Portfolio Application: Regime-dependent allocations

Change Point Detection

CUSUM Tests: Detect structural breaks Application: Model re-estimation triggers

Multi-Asset Integration

Currency Hedging

Hedging Decision: Cost-benefit analysis Dynamic Hedging: Time-varying hedge ratios

Alternative Assets

Real Estate: REITs, direct investment Commodities: Inflation hedge, diversification Private Equity:
Liquidity premium, selection bias

10. Common Pitfalls & Solutions {#pitfalls}

Data Quality Issues

Missing Data Problems

Types of Missingness:

MCAR (Missing Completely at Random): Random equipment failure

MAR (Missing at Random): Systematic but predictable
MNAR (Missing Not at Random): Related to unobserved values

Solutions:
 python

# Forward fill for time series

df.fillna(method='ffill')

# Interpolation
df.interpolate(method='linear')
df.interpolate(method='spline', order=2)

# Model-based imputation
from sklearn.impute import KNNImputer

Outlier Detection

Statistical Methods:

Z-score: |z| > 3

IQR method: Outside Q1-1.5IQR to Q3+1.5IQR

Modified Z-score: More robust

Time Series Specific:

Seasonal-Trend decomposition residuals

ARIMA residuals analysis

Treatment Options:

1. Remove: If clearly erroneous

2. Cap: Winsorization at percentiles

3. Transform: Log transformation reduces impact

4. Model: Robust regression methods

Sampling Frequency Issues

Aliasing: High-frequency signals appear as low-frequency Solution: Proper anti-aliasing filters

Mixed Frequencies: Daily + monthly data Solution: Bridge sampling, state space models

Model Selection Mistakes

Overfitting Traps

In-Sample vs Out-of-Sample: Model fits historical data perfectly but fails future data
Analogy: Memorizing specific exam questions vs understanding concepts

Solutions:

Cross-validation with time series splits

Information criteria (AIC, BIC)

Holdout testing periods

Ensemble methods

Look-Ahead Bias

Problem: Using future information to make past predictions Examples:

Using end-of-day prices for intraday signals

Applying future parameter estimates to historical data

Prevention:

Strict chronological data splits

Walk-forward validation

Point-in-time datasets

Survivorship Bias

Problem: Only analyzing assets that survived the entire period Impact: Overestimated performance,
underestimated risk

Solution: Include delisted/bankrupt assets in analysis

Statistical Assumption Violations

Non-Constant Variance (Heteroskedasticity)

Detection: Residual plots, Breusch-Pagan test Consequences: Inefficient estimates, wrong standard
errors

Solutions:

GARCH models for time-varying variance

Robust standard errors

Weighted least squares

Serial Correlation in Residuals

Problem: Model doesn't capture all temporal dependencies Detection: Ljung-Box test, ACF of residuals

Solutions:

Higher-order ARMA terms

Different model specification

Robust standard errors (Newey-West)

Non-Normality of Residuals

Consequences: Invalid inference, poor forecasts