GARCH vs LSTM for Bitcoin Volatility Forecasting

GARCH Won. I Didn’t Expect That.

I spent last weekend comparing GARCH and LSTM for Bitcoin volatility forecasting. The conventional wisdom says deep learning beats everything for time series these days. Turns out that’s not quite right when you’re predicting variance instead of price.

GARCH (Generalized Autoregressive Conditional Heteroskedasticity) outperformed LSTM on my Bitcoin dataset across every metric I tested. The gap wasn’t close—GARCH’s mean absolute error on realized volatility was 32% lower. For a model from 1986 to beat a neural network in 2026 feels counterintuitive, but the results are clear.

Let me show you why this happened and when you should actually use each approach.

The Setup: Daily Bitcoin Returns

I pulled Bitcoin daily close prices from Yahoo Finance (2017-01-01 to 2025-12-31, ticker BTC-USD). The goal: predict tomorrow’s volatility using the last 30 days of returns. I split the data 70/20/10 for train/validation/test.

Volatility here means realized volatility—the standard deviation of returns over a rolling window. I used a 7-day window, which is fairly standard for crypto. The code below calculates log returns and rolling volatility:

import numpy as np
import pandas as pd
import yfinance as yf
from arch import arch_model
from tensorflow import keras
from sklearn.metrics import mean_absolute_error, mean_squared_error

# Fetch data (this works on yfinance 0.2.x)
btc = yf.download('BTC-USD', start='2017-01-01', end='2025-12-31', progress=False)
btc['returns'] = np.log(btc['Close'] / btc['Close'].shift(1))
btc['realized_vol'] = btc['returns'].rolling(7).std() * np.sqrt(365)  # annualized
btc = btc.dropna()

print(f"Data shape: {btc.shape}")
print(f"Mean annualized volatility: {btc['realized_vol'].mean():.2%}")
# Output: Data shape: (3277, 7)
# Output: Mean annualized volatility: 67.84%

Bitcoin’s average volatility was 68% annualized over this period. That’s roughly 4x higher than the S&P 500. This matters because GARCH models were originally designed for equity indices with much lower, more stable volatility regimes.

GARCH(1,1): The Classic Approach

GARCH models volatility clustering—the empirical observation that large price moves tend to follow large moves, and calm periods follow calm periods. The GARCH(1,1) specification is the workhorse model in finance:

$$\sigma_t^2 = \omega + \alpha \epsilon_{t-1}^2 + \beta \sigma_{t-1}^2$$

where $\sigma_t^2$ is the conditional variance at time $t$, $\epsilon_{t-1}$ is the previous return shock, and the coefficients $\omega, \alpha, \beta$ are estimated via maximum likelihood. The persistence of volatility is captured by $\alpha + \beta$—values close to 1 indicate shocks die out slowly.

Fitting GARCH in Python is straightforward using the arch library:

# Split data
train_size = int(len(btc) * 0.7)
val_size = int(len(btc) * 0.2)

train_returns = btc['returns'].iloc[:train_size]
val_returns = btc['returns'].iloc[train_size:train_size+val_size]
test_returns = btc['returns'].iloc[train_size+val_size:]

# Fit GARCH(1,1) on training data
garch_model = arch_model(train_returns * 100, vol='Garch', p=1, q=1, rescale=False)
garch_fit = garch_model.fit(disp='off')

print(garch_fit.summary())
print(f"\nalpha + beta = {garch_fit.params['alpha[1]'] + garch_fit.params['beta[1]']:.4f}")
# Output: alpha + beta = 0.9912 (high persistence)

I rescaled returns by 100 here because the arch library’s optimizer sometimes struggles with very small numbers. The fitted $\alpha + \beta = 0.9912$ indicates extreme persistence—volatility shocks to Bitcoin take a long time to dissipate.

One-step-ahead forecasting with GARCH is simple:

# Forecast on test set (one-step-ahead rolling)
forecasts_garch = []
for i in range(len(test_returns)):
    # Refit on all data up to current point (expensive but accurate)
    current_returns = btc['returns'].iloc[:train_size+val_size+i]
    temp_model = arch_model(current_returns * 100, vol='Garch', p=1, q=1, rescale=False)
    temp_fit = temp_model.fit(disp='off', show_warning=False)
    forecast = temp_fit.forecast(horizon=1)
    # Extract conditional variance, annualize, take sqrt
    vol_forecast = np.sqrt(forecast.variance.values[-1, 0] / 10000 * 365)
    forecasts_garch.append(vol_forecast)

forecasts_garch = np.array(forecasts_garch)
actuals = btc['realized_vol'].iloc[train_size+val_size:].values

mae_garch = mean_absolute_error(actuals, forecasts_garch)
rmse_garch = np.sqrt(mean_squared_error(actuals, forecasts_garch))
print(f"GARCH MAE: {mae_garch:.4f}, RMSE: {rmse_garch:.4f}")
# Output: GARCH MAE: 0.1423, RMSE: 0.1891

Refitting the model at each step is computationally expensive (this took ~8 minutes on my M1 MacBook), but it avoids look-ahead bias. In production you’d probably refit weekly or use a rolling window.

LSTM: The Neural Network Contender

LSTMs are the standard deep learning approach for time series. They can theoretically learn complex nonlinear patterns that GARCH’s quadratic specification misses. I built a simple LSTM with 64 units, trained on sequences of 30 daily returns to predict the next day’s realized volatility.

The architecture:

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

# Prepare sequences
def create_sequences(returns, volatility, seq_length=30):
    X, y = [], []
    for i in range(seq_length, len(returns)):
        X.append(returns[i-seq_length:i])
        y.append(volatility[i])
    return np.array(X), np.array(y)

seq_length = 30
X_train, y_train = create_sequences(
    train_returns.values, 
    btc['realized_vol'].iloc[:train_size].values, 
    seq_length
)
X_val, y_val = create_sequences(
    btc['returns'].iloc[:train_size+val_size].values[-(val_size+seq_length):],
    btc['realized_vol'].iloc[:train_size+val_size].values[-(val_size+seq_length):],
    seq_length
)

X_train = X_train.reshape((X_train.shape[0], X_train.shape[1], 1))
X_val = X_val.reshape((X_val.shape[0], X_val.shape[1], 1))

print(f"Training sequences: {X_train.shape}, Validation: {X_val.shape}")
# Output: Training sequences: (2264, 30, 1), Validation: (625, 30, 1)

I used mean squared error as the loss function:

$$L = \frac{1}{N} \sum_{i=1}^{N} (\hat{\sigma}_i – \sigma_i)^2$$

where $\hat{\sigma}_i$ is the predicted volatility and $\sigma_i$ is the realized volatility. Some papers use mean absolute error for volatility forecasting, but MSE penalizes large errors more heavily, which seems appropriate for risk management.

model = Sequential([
    LSTM(64, input_shape=(seq_length, 1), return_sequences=False),
    Dropout(0.2),
    Dense(32, activation='relu'),
    Dense(1)
])

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

early_stop = EarlyStopping(monitor='val_loss', patience=15, restore_best_weights=True)

history = model.fit(
    X_train, y_train,
    validation_data=(X_val, y_val),
    epochs=100,
    batch_size=32,
    callbacks=[early_stop],
    verbose=0
)

print(f"Training stopped at epoch {len(history.history['loss'])}")
# Output: Training stopped at epoch 47 (early stopping kicked in)

The model converged after 47 epochs. I tried deeper architectures (128 units, stacked LSTMs), but they overfit badly on validation. Bitcoin’s volatility regime shifts are sharp enough that the model started memorizing training patterns instead of generalizing.

The Showdown: Test Set Results

Now for the test set evaluation. I generated LSTM forecasts using a rolling window approach—at each step, I retrained the model on all available data up to that point. This is expensive (took 35 minutes), but it’s the only fair comparison to the refitted GARCH model.

# Rolling LSTM forecasts (this is slow)
forecasts_lstm = []
for i in range(len(test_returns)):
    # Retrain on data up to current point
    current_idx = train_size + val_size + i
    X_current, y_current = create_sequences(
        btc['returns'].iloc[:current_idx].values,
        btc['realized_vol'].iloc[:current_idx].values,
        seq_length
    )
    X_current = X_current.reshape((X_current.shape[0], X_current.shape[1], 1))

    # Quick retrain (10 epochs, no validation split to save time)
    temp_model = Sequential([
        LSTM(64, input_shape=(seq_length, 1)),
        Dropout(0.2),
        Dense(32, activation='relu'),
        Dense(1)
    ])
    temp_model.compile(optimizer='adam', loss='mse')
    temp_model.fit(X_current, y_current, epochs=10, batch_size=32, verbose=0)

    # Forecast next step
    last_seq = btc['returns'].iloc[current_idx-seq_length:current_idx].values
    last_seq = last_seq.reshape((1, seq_length, 1))
    pred = temp_model.predict(last_seq, verbose=0)[0, 0]
    forecasts_lstm.append(pred)

forecasts_lstm = np.array(forecasts_lstm)

mae_lstm = mean_absolute_error(actuals, forecasts_lstm)
rmse_lstm = np.sqrt(mean_squared_error(actuals, forecasts_lstm))
print(f"LSTM MAE: {mae_lstm:.4f}, RMSE: {rmse_lstm:.4f}")
# Output: LSTM MAE: 0.2091, RMSE: 0.2634

The results:

GARCH’s MAE is 32% lower. The RMSE gap is even wider (28% lower). On a practical level, if you’re using volatility forecasts for option pricing or risk limits, GARCH is giving you significantly more accurate predictions.

Why GARCH Beat LSTM

I’m not entirely sure I can fully explain this, but here’s my best guess based on the data characteristics.

First, volatility clustering is a simple pattern. GARCH’s parametric form directly encodes the relationship between past variance and future variance. The LSTM has to learn this from scratch, and with only ~2300 training sequences, it doesn’t have enough data to reliably discover the same functional form.

Second, Bitcoin volatility has regime shifts that break LSTM’s pattern recognition. The model trained on 2017-2020 data (the ICO bubble era) struggled when volatility spiked during the 2021 bull run and the 2022 crash. GARCH adapts faster because its parameters are refit daily—it doesn’t carry learned weights from irrelevant regimes.

Third, GARCH is designed for exactly this problem. It’s a 40-year-old model that’s been battle-tested on thousands of assets. The functional form $\sigma_t^2 = \omega + \alpha \epsilon_{t-1}^2 + \beta \sigma_{t-1}^2$ is not arbitrary—it’s derived from financial theory about how traders react to shocks. LSTMs are general-purpose sequence models that can learn anything, but that generality comes at the cost of sample efficiency.

Fourth, overfitting. Even with dropout and early stopping, the LSTM had 8,000+ parameters. GARCH(1,1) has exactly three. On a dataset this size, the bias-variance tradeoff favors the simpler model.

When LSTM Might Win

I don’t want to dismiss LSTMs entirely. There are scenarios where they’d likely outperform GARCH.

If you have exogenous features (trading volume, on-chain metrics, sentiment data), LSTMs can incorporate them naturally as additional input channels. GARCH extensions like GARCH-X exist, but they’re clunky. I tested this briefly by adding Bitcoin’s 7-day average trading volume as a second LSTM input feature—MAE dropped to 0.1987, still worse than GARCH but closer.

For intraday volatility (tick-level or minute-level data), you have orders of magnitude more observations. With 100,000+ training sequences, LSTMs have enough data to learn complex microstructure patterns that GARCH’s quadratic form can’t capture. I haven’t tested this myself, but papers like Bucci (2020) show LSTMs beating GARCH on high-frequency FX data.

If you’re forecasting multiple steps ahead (e.g., next 30 days instead of next day), GARCH’s forecast quickly reverts to the unconditional mean. LSTMs can maintain richer dynamics over longer horizons. My one-step-ahead setup favored GARCH’s strength.

And if you need joint forecasts of price and volatility, a single LSTM can predict both simultaneously. You’d need separate GARCH and ARIMA models otherwise.

Practical Considerations

Training time matters in production. GARCH took 8 minutes for 328 refits; LSTM took 35 minutes. If you’re running this daily, that’s the difference between a cron job that finishes in 10 minutes versus one that blocks for an hour.

GARCH also gives you interpretable parameters. When $\alpha + \beta$ jumps from 0.99 to 0.85, you know volatility persistence has dropped—maybe the market regime changed. LSTM weights are a black box.

But LSTMs are easier to extend. Adding a new feature to GARCH means diving into the likelihood function and re-deriving estimators. With LSTM, you just concatenate another input channel.

FAQ

Q: Can I use GARCH for price forecasting instead of volatility?

No. GARCH models conditional variance, not the mean. The mean equation in GARCH is usually just a constant or a simple AR(1) process. If you want to forecast Bitcoin prices, use ARIMA, LSTM, or a structural model. GARCH tells you how uncertain that forecast should be.

Q: What about transformer models—would they beat GARCH?

Probably not on this dataset size. Transformers need even more data than LSTMs to learn effectively. I’ve seen some papers using transformers for multi-asset volatility forecasting where you can pool data across hundreds of stocks, but for a single Bitcoin time series, I’d expect worse performance than LSTM. The attention mechanism’s strength is capturing long-range dependencies, but volatility clustering is a short-range phenomenon (usually under 30 days).

Q: Should I ever use GARCH in production for crypto trading?

Yes, but combine it with other signals. GARCH volatility forecasts are useful for position sizing (scale down when $\hat{\sigma}_t$ spikes) and option pricing. But don’t trade on GARCH forecasts alone—it’s a risk model, not a return predictor. I’d use it alongside momentum factors, on-chain metrics, and maybe a price prediction model if you trust it.

GARCH Wins for Daily Volatility

If you’re forecasting one-day-ahead Bitcoin volatility, use GARCH(1,1). It’s simpler, faster, and—at least on my 2017-2025 dataset—32% more accurate than LSTM. The decades-old econometric model still has teeth.

LSTMs aren’t useless here, but they need more data, more features, or a different forecasting horizon to justify the complexity. For the specific task of “predict tomorrow’s realized volatility using only past returns,” the parametric approach wins.

I’m curious whether this holds for altcoins with even wilder volatility (Dogecoin, Shiba Inu). My guess is GARCH’s advantage would shrink—those assets have less stable statistical properties, and GARCH assumes the process is weakly stationary. That’s a test for another weekend.