Volatility
Key Concepts
Introduction
Volatility models measure the historical volatility of an asset. They are mostly used to calculate the volatility of the underlying security of an Option because the implied volatility of an Option contract needs an initial guess. The historical volatility doesn't need to be the standard deviation of the asset prices. The various volatility models in LEAN each have a unique methodology to calculate volatility.
LEAN also provides an indicator implementation of implied volatility. It provides higher flexibility on Option price model selection, volatility modeling, and allows IV smoothing through call-put pair. For details, see Implied Volatility.
Set Models
To set the volatility model of the underlying security of an Option, set the VolatilityModel property of the Security object. The volatility model can have a different resolution than the underlying asset subscription.
public override void Initialize()
{
var underlyingSecurity = AddEquity("SPY");
// Usually, the historical and implied volatility is calculated using 30-day standard deviation of return
underlyingSecurity.VolatilityModel = new StandardDeviationOfReturnsVolatilityModel(30);
} def initialize(self) -> None:
underlying_security = self.add_equity("SPY")
# Usually, the historical and implied volatility is calculated using 30-day standard deviation of return
underlying_security.volatility_model = StandardDeviationOfReturnsVolatilityModel(30)
You can also set the volatility model in a security initializer. If your algorithm has a universe of underlying assets, use the security initializer technique. In order to initialize single security subscriptions with the security initializer, call AddSecurityInitializeradd_security_initializer before you create the subscriptions.
public class AddSecurityInitializerExampleAlgorithm : QCAlgorithm
{
public override void Initialize()
{
// In the Initialize method, set the security initializer to set models of assets.
AddSecurityInitializer(CustomSecurityInitializer);
}
private void CustomSecurityInitializer(Security security)
{
// Overwrite the volatility model
if (security.Type == SecurityType.Equity)
{
security.VolatilityModel = new StandardDeviationOfReturnsVolatilityModel(30);
}
}
} class AddSecurityInitializerExampleAlgorithm(QCAlgorithm):
def initialize(self) -> None:
# In the Initialize method, set the security initializer to set models of assets.
self.add_security_initializer(self._custom_security_initializer)
def _custom_security_initializer(self, security: Security) -> None:
# Overwrite the volatility model
if security.Type == SecurityType.EQUITY:
security.volatility_model = StandardDeviationOfReturnsVolatilityModel(30)
To view all the pre-built volatility models, see Supported Models.
Default Behavior
The default underlying volatility model for Equity Options and Index Options is the StandardDeviationOfReturnsVolatilityModel based on 30 days of daily resolution data. The default underlying volatility model for Future Options is the NullVolatilityModel.
Model Structure
Volatility models should extend the BaseVolatilityModel class. Extensions of the BaseVolatilityModel class must have Updateupdate and GetHistoryRequirementsget_history_requirements methods and a Volatilityvolatility property. The Updateupdate method receives Security and BaseData objects and then updates the Volatilityvolatility. The GetHistoryRequirementsget_history_requirements method receives Security and DateTimedatetime objects and then returns a list of HistoryRequest objects that represent the history requests to warm up the model. Volatility models receive data at each time step in the algorithm to update their state.
public class CustomVolatilityModelExampleAlgorithm : QCAlgorithm
{
public override void Initialize()
{
var underlyingSecurity = AddIndex("VIX");
// Apply custom volatility model for specific underlyings, often they are synthetic products or with different market calendar
underlyingSecurity.VolatilityModel = new MyVolatilityModel();
}
}
// Define the custom volatility model outside of the algorithm
public class MyVolatilityModel : BaseVolatilityModel
{
public override decimal Volatility { get; }
public override void SetSubscriptionDataConfigProvider(
ISubscriptionDataConfigProvider subscriptionDataConfigProvider)
{
SubscriptionDataConfigProvider = subscriptionDataConfigProvider;
}
public override void Update(Security security, BaseData data)
{
}
public override IEnumerable<HistoryRequest> GetHistoryRequirements(
Security security,
DateTime utcTime)
{
return base.GetHistoryRequirements(security, utcTime);
}
public new IEnumerable<HistoryRequest> GetHistoryRequirements(
Security security,
DateTime utcTime,
Resolution? resolution,
int barCount)
{
return base.GetHistoryRequirements(security, utcTime, resolution, barCount);
}
} class CustomVolatilityModelExampleAlgorithm(QCAlgorithm):
def initialize(self) -> None:
underlying_security = self.add_index("VIX")
# Apply custom volatility model for specific underlyings, often they are synthetic products or with different market calendar
underlying_security.volatility_model = MyVolatilityModel()
# Define the custom volatility model outside of the algorithm
class MyVolatilityModel(BaseVolatilityModel):
volatility: float = 0
def set_subscription_data_config_provider(self,
subscription_data_config_provider: ISubscriptionDataConfigProvider) -> None:
super().set_subscription_data_config_provider(subscription_data_config_provider)
def update(self, security: Security, data: BaseData) -> None:
pass
def get_history_requirements(
self,
security: Security,
utc_time: datetime | date,
resolution: Resolution | None = None,
bar_count: int = 0) -> Iterable[HistoryRequest]:
return super().get_history_requirements(security, utc_time, resolution, bar_count)
Warm Up Models
To use your volatility model as the inital guess for the implied volatility, warm up the volatility model of the underlying security. If you subscribe to all the Options in the Initializeinitialize method, set a warm-up period to warm up their volatility models. The warm-up period should provide the volatility models with enough data to compute their values.
public override void Initialize()
{
// For default 30-day SD of return as volatility, you need 30+1 trading day to warm up
SetWarmUp(31, Resolution.Daily);
}
public override void OnData(Slice slice)
{
// Only take the warmed-up volatility value into account for accuracy issue
if (IsWarmingUp) return;
} def initialize(self) -> None:
# For default 30-day SD of return as volatility, you need 30+1 trading day to warm up
self.set_warm_up(30, Resolution.DAILY)
def on_data(self, slice: Slice) -> None:
# Only take the warmed-up volatility value into account for accuracy issue
if self.is_warming_up:
return
If you have a dynamic universe of underlying assets and add Option contracts to your algorithm with the AddOptionContractadd_option_contract, AddIndexOptionContractadd_index_option_contract, or AddFutureOptionContractadd_future_option_contract methods, warm up the volatility model when the underlying asset enters your universe. We recommend you do this inside a security initializer.
public class AddSecurityInitializerExampleAlgorithm : QCAlgorithm
{
public override void Initialize()
{
// In the Initialize method, set the security initializer to set models of assets.
AddSecurityInitializer(CustomSecurityInitializer);
}
private void CustomSecurityInitializer(Security security)
{
// Overwrite and warm up the volatility model
if (security.Type == SecurityType.Equity) // Underlying asset type
{
security.VolatilityModel = new StandardDeviationOfReturnsVolatilityModel(30);
foreach (var tradeBar in History(security.Symbol, 30, Resolution.Daily))
{
security.VolatilityModel.Update(security, tradeBar);
}
}
}
} class AddSecurityInitializerExampleAlgorithm(QCAlgorithm):
def initialize(self) -> None:
# In the Initialize method, set the security initializer to set models of assets.
self.add_security_initializer(self._custom_security_initializer)
def _custom_security_initializer(self, security: Security) -> None:
# Overwrite and warm up the volatility model
if security.type == SecurityType.EQUITY: # Underlying asset type
security.volatility_model = StandardDeviationOfReturnsVolatilityModel(30)
trade_bars = self.history[TradeBar](security.symbol, 30, Resolution.DAILY)
for trade_bar in trade_bars:
security.volatility_model.update(security, trade_bar)
Examples
The following examples demonstrate common practices for implementing a custom volatility model.
Example 1: Default Model Wrapper
The following algorithm defines a subclass of the BaseVolatilityModel and overrides its built-in members so you can easily customize the parts you need.
public class CustomVolatilityModelAlgorithm : QCAlgorithm
{
public override void Initialize()
{
SetStartDate(2024, 9, 1);
SetEndDate(2024, 12, 31);
SetCash(100000);
var security = AddEquity("SPY", Resolution.Daily);
security.VolatilityModel = new MyVolatilityModel();
}
/// OnData event is the primary entry point for your algorithm. Each new data point will be pumped in here.
/// Slice object keyed by symbol containing the stock data
public override void OnData(Slice data)
{
if (!Portfolio.Invested)
{
SetHoldings("SPY", 1);
}
}
}
public class MyVolatilityModel : BaseVolatilityModel
{
public override decimal Volatility { get; }
public override void SetSubscriptionDataConfigProvider(
ISubscriptionDataConfigProvider subscriptionDataConfigProvider)
{
SubscriptionDataConfigProvider = subscriptionDataConfigProvider;
}
public override void Update(Security security, BaseData data)
{
}
public override IEnumerable<HistoryRequest> GetHistoryRequirements(
Security security,
DateTime utcTime)
{
return base.GetHistoryRequirements(security, utcTime);
}
public new IEnumerable<HistoryRequest> GetHistoryRequirements(
Security security,
DateTime utcTime,
Resolution? resolution,
int barCount)
{
return base.GetHistoryRequirements(security, utcTime, resolution, barCount);
}
}
class CustomVolatilityModelAlgorithm(QCAlgorithm):
def initialize(self) -> None:
self.set_start_date(2024, 9, 1)
self.set_end_date(2024, 12, 31)
self.set_cash(100000)
security = self.add_equity('SPY', Resolution.DAILY)
security.volatility_model = MyVolatilityModel()
def on_data(self, data: Slice) -> None:
if not self.portfolio.invested:
self.set_holdings('SPY', 1)
class MyVolatilityModel(BaseVolatilityModel):
volatility: float = 0
def set_subscription_data_config_provider(self,
subscription_data_config_provider: ISubscriptionDataConfigProvider) -> None:
super().set_subscription_data_config_provider(subscription_data_config_provider)
def update(self, security: Security, data: BaseData) -> None:
pass
def get_history_requirements(
self,
security: Security,
utc_time: datetime | date,
resolution: Resolution | None = None,
bar_count: int = 0) -> Iterable[HistoryRequest]:
return super().get_history_requirements(security, utc_time, resolution, bar_count)
Other Examples
For more examples, see the following algorithms:
You can also see our Videos. You can also get in touch with us via Discord.
Did you find this page helpful?
