Quantile Curves and the VRP
Log in to collectOnsite backtest IDE
Quant Buffet native backtest IDEEdit and run Quant Buffet Python for Quantile Curves and the VRP in the browser. Results update live with equity, drawdown, and metrics charts. Allowed: backtest.data, backtest.engine, backtest.metrics, numpy, pandas. Define ASSETS and make_on_day(prices). Shortcut: Ctrl+Enter. API docs →
Quant Buffet syntax cheat sheet (copy / insert)
Paste these fragments into the editor. The sandbox rejects QuantConnect, os, and network libraries.
from __future__ import annotations
import numpy as np
import pandas as pd
from backtest.data import load_daily_prices
from backtest.engine import EngineConfig, PortfolioEngine
from backtest.metrics import compute_metricsASSETS = ["SPY", "QQQ", "TLT", "GLD", "BIL"]def make_on_day(prices: pd.DataFrame):
cols = [c for c in ASSETS if c in prices.columns]
sma = prices[cols].rolling(200, min_periods=200).mean()
state = {"last": None}
def on_day(engine: PortfolioEngine, dt: pd.Timestamp) -> None:
if sma.loc[dt].isna().all():
return
key = (dt.year, dt.month)
if state["last"] == key:
return
state["last"] = key
long = [
s for s in cols
if pd.notna(prices.at[dt, s]) and pd.notna(sma.at[dt, s])
and prices.at[dt, s] > sma.at[dt, s]
]
weights = {} if not long else {s: 1.0 / len(long) for s in long}
engine.set_target_weights(dt, weights)
ready = sma.dropna(how="all").index.min() if sma.notna().any().any() else None
return on_day, readyengine.set_target_weights(dt, {"SPY": 0.60, "BIL": 0.40})Live backtest performance
Export to your platform
Transform Quant Buffet lab code (ASSETS + make_on_day / PortfolioEngine) into native classes for a third-party IDE — then copy and paste.
# Generated from Quant Buffet → QuantConnect LEAN
# Strategy: Quantile Curves and the VRP
# Detected pattern: Absolute momentum
# Source uses Quant Buffet lab APIs (ASSETS + make_on_day / PortfolioEngine).
# Review fees, data, and risk before live trading — educational export only.
from AlgorithmImports import *
class QuantBuffetExport(QCAlgorithm):
def Initialize(self):
self.SetStartDate(2010, 1, 1)
self.SetCash(100000)
tickers = ["SPY", "TLT", "GLD", "BIL"]
self.symbols = []
for t in tickers:
if "-" in t: # crypto proxy e.g. BTC-USD
self.symbols.append(self.AddCrypto(t.replace("-USD", ""), Resolution.Daily).Symbol)
else:
self.symbols.append(self.AddEquity(t, Resolution.Daily).Symbol)
self.Schedule.On(
self.DateRules.MonthStart(self.symbols[0]),
self.TimeRules.AfterMarketOpen(self.symbols[0], 30),
self.Rebalance,
)
# Logic: Long assets with positive 252-day return; equal-weight; monthly.
def Rebalance(self):
# Pattern: abs_momentum — Long assets with positive 252-day return; equal-weight; monthly.
# Default: equal-weight. Port your make_on_day weights here via SetHoldings.
w = 1.0 / len(self.symbols) if self.symbols else 0.0
for symbol in self.symbols:
self.SetHoldings(symbol, w)
Exported code uses the platform’s native classes and libraries. Install dependencies in your third-party IDE, then run. Validate before live trading.
Academic paper
Cross-Section of Option Returns and the Volatility Risk Premium
Simon Fritzsch; Felix Irresberger; Gregor Weiß
- DELeipzig University
- ?University of Leipzig - Faculty of Economics and Management Science
- Durham University
https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3864131
Strategy in a nutshell
The strategy focuses on US equity American options using data from CRSP and the OptionMetrics IvyDB US database. It restricts the sample to options with one month to expiration and applies several filters, excluding cases where the ask price is below the bid, the bid equals zero, the bid–ask spread is narrower than the minimum tick size, or arbitrage bounds are violated. Options are further limited to a moneyness range between 0.5 and 1.5. The key inputs are implied volatility, moneyness, and realized volatility, with the latter calculated as the standard deviation of daily stock returns over the previous twelve months. The first step of the strategy is to construct the conditional quantile function of implied volatility given realized volatility and moneyness, which is estimated by minimizing the check-loss of the residuals using the “leveraging” machine learning technique introduced by Meir and Rätsch (2003). Based on this quantile curve, decile portfolios are formed, and the trading rule is to go long delta-hedged call options in the highest decile and short delta-hedged call options in the lowest decile. The positions are held until maturity, portfolios are equally weighted, and rebalancing occurs monthly.
Economic rationale
The economic rationale behind the approach is that traditional sorts based on the difference between realized and implied volatilities unintentionally create portfolios that are systematically unbalanced, for instance by being long high-realized-volatility options and short low-realized-volatility ones. The quantile curve method addresses this issue by controlling directly for realized volatility and moneyness, ensuring more balanced portfolio construction and eliminating biases caused by structural differences in volatility or option characteristics. This method also has several advantages: it does not require assuming a specific functional form for the relationship between implied and realized volatility, it helps avoid the issue of empty portfolios, and it allows the inclusion of additional conditioning variables if needed. Finally, once the quantile curves are estimated, the strategy is straightforward to implement on a recurring monthly basis.