Beta hedging

This page shows the construction of a beta hedge for strategies built on the SigTech platform. A beta hedge serves to offset the volatility associated with trading a financial instrument or portfolio.
Environment
Begin by setting up your environment:
1
import pandas as pd
2
import seaborn as sns
3
from uuid import uuid4
4
​
5
import sigtech.framework as sig
6
​
7
sns.set(rc={'figure.figsize': (18, 6)})
8
sig.init()
Copied!
Learn more: Setting up your environment​
Simple example
Rolling beta
The following example demonstrates how to use a rolling ES SP500 futures strategy as a beta hedge for a rolling NQ Nasdaq futures strategy.
Start by importing ES and NQ default rolling futures strategies, and then build them:
1
from sigtech.framework.default_strategy_objects.rolling_futures \
2
    import es_index_front, nq_index_front
3
nq_rfs = nq_index_front()
4
es_rfs = es_index_front()
5
nq_rfs.build()
6
es_rfs.build()
Copied!
Use the rolling_beta method from the SigTech signal_library to compute the rolling beta of nq_rfs to es_rfs. The rolling window is set to 60 days:
1
window = 60
2
beta = sig.signal_library.core.rolling_beta(
3
    ts=nq_rfs.history(), market_ts=es_rfs.history(), window=window
4
).dropna()
5
beta.plot(title='Rolling Beta: NQ to ES');
Copied!
As expected, the beta of NQ to ES is mostly above 1. This is due to the higher level of volatility generally associated with NQ.
Hedging with the signal strategy
Once the rolling beta exposure is computed, create a signal that assigns 1.0 to the strategy to be hedged, nq_rfs, and − beta to the hedging instrument, es_rfs.
1
signal = pd.DataFrame.from_dict({
2
    nq_rfs.name: 1.0, 
3
    es_rfs.name: - beta
4
})
Copied!
Combine this signal with the SignalStrategy building block to create a beta hedged version of a strategy:
1
def get_hedged_strategy(signal, freq):
2
    strategy = sig.SignalStrategy(
3
        signal_name=sig.signal_library.core.from_ts(signal).name,
4
        start_date=signal.first_valid_index(),
5
        currency='USD',
6
        rebalance_frequency=freq,
7
        ticker=f'BetaHedgedStrategy_{freq}_{str(uuid4())[:4]}'
8
    )
9
    strategy.build()
10
    return strategy
Copied!
Impact of the beta estimation window
To examine the impact of the rebalancing frequency on the hedged strategy:
1
frequencies = ['2BD', '1W', 'EOM', '60BD', '6M']
2
bh_strategies = {freq: get_hedged_strategy(signal, freq) for freq in frequencies}
3
strategy_histories = pd.concat(
4
    {f: s.history() for f, s in bh_strategies.items()}, axis=1)
5
strategy_histories.plot();
Copied!
Realised beta
The following code block measures the impact of the realised beta on the hedged strategy. As expected, more frequent rebalancing tends to decrease the magnitude of the realised beta:
1
realised_betas = {}
2
for f, s in bh_strategies.items():
3
    realised_betas[f] = sig.signal_library.core.rolling_beta(
4
        ts=s.history(), market_ts=es_rfs.history(), window=window
5
    ).dropna()
6
pd.DataFrame(realised_betas).plot(title='Realised Rolling Betas');
Copied!

Portfolio Construction & Risk Management - Previous

Simulations & scenarios

Next - Platform

Strategy deployment

Last modified 1mo ago

Export as PDF

Copy link

Contents

Environment

Simple example