gulp>> Dynamic-Derivatives-Portfolio-Hedging>> 返回
项目作者： bottama

项目描述 ：
Algorithmic Portfolio Hedging. Black-Scholes Pricing for Dynamic Hedges to produce a Dynamic multi-asset Portfolio Hedging with the usage of Options contracts.
高级语言： Python
项目地址: git://github.com/bottama/Dynamic-Derivatives-Portfolio-Hedging.git


Dynamic Portfolio Hedging

Delta, Gamma and Vega Portfolio Neutral

Last Update March 12, 2021

Matteo Bottacini, matteo.bottacini@usi.ch

Project description

In this project it is discussed how to construct a Dynamic multi-asset Portfolio Hedging with the usage of Options contracts.

NVDA boomed over the last 2 years and here is discussed how to hedge a short position in NVDA calls.
The aim is to hedge the exposure to changes in volatility, movements in the underlying asset and the speed of movements in the underlying asset.

Options have exposure to not only the underlying asset but also interest rates, time, and volatility.
These exposures are inputs to the Black-Scholes option pricing model.

While building the script, it is also explored the intuition behind the Black-Scholes model.

Folder structure:

  1. Dynamic-Derivatives-Portfolio-Hedging/
  2.     deliverables/
  3.         asset-allocation.py
  4.     src/
  5.         utils.py
  6.         variables.py
  7.     README.md

Content

  • Main variables
  • Black-Scholes-Merton (BS) model
  • Greeks
  • Dynamic hedging
  • Portfolio position
  • Greek neutralization
  • Final Delta, Gamma, and Vega Neutral Portfolio
  • Conclusion

Main variables

In the file ../src/variables.py are set all the different variables that for a dynamic hedge needs to be updated daily.
Feel free to play with these variables and create different settings.

  1. # main variables
  3. # asset_price : underlying price
  4. # sigma       : implied volatility to insert for the BS model
  5. # dt          : time to expiration
  6. # rf          : risk free rate (30 day LIBOR rate)
  7. # nContract1  : number of contracts
  8. # K1          : strike price option 1
  9. # K2          : strike price option 2
  10. # K3          : strike price option 3
  12. # underlying
  13. asset_price = 543
  15. # input BS
  16. sigma = 0.53
  17. dt = 30/365
  18. rf = .015
  20. # option 1
  21. nContract1 = -1000
  22. K1 = 545
  24. # option 2
  25. K2 = 550
  27. # option 3
  28. K3 = 570

Black-Scholes-Merton (BS) model

In the file ../src/utils.py is described the model to price the European Options with the BS model.

The following code models European calls:

  1. import math
  2. from scipy.stats import norm
  4. # define the European call option
  5. class EuropeanCall:
  7.     def call_price(
  8.             self, asset_price, asset_volatility, strike_price,
  9.             time_to_expiration, risk_free_rate
  10.     ):
  11.         b = math.exp(-risk_free_rate * time_to_expiration)
  12.         x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  13.                     asset_volatility * asset_volatility) * time_to_expiration
  14.         x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  15.         z1 = norm.cdf(x1)
  16.         z1 = z1 * asset_price
  17.         x2 = math.log(asset_price / (b * strike_price)) - .5 * (
  18.                     asset_volatility * asset_volatility) * time_to_expiration
  19.         x2 = x2 / (asset_volatility * (time_to_expiration ** .5))
  20.         z2 = norm.cdf(x2)
  21.         z2 = b * strike_price * z2
  22.         return z1 - z2
  24.     def __init__(
  25.             self, asset_price, asset_volatility, strike_price,
  26.             time_to_expiration, risk_free_rate
  27.     ):
  28.         self.asset_price = asset_price
  29.         self.asset_volatility = asset_volatility
  30.         self.strike_price = strike_price
  31.         self.time_to_expiration = time_to_expiration
  32.         self.risk_free_rate = risk_free_rate
  33.         self.price = self.call_price(asset_price, asset_volatility, strike_price, time_to_expiration, risk_free_rate)

The following code models European puts:

  1. import math
  2. from scipy.stats import norm
  4. # define the European put option
  5. class EuropeanPut:
  7.     def put_price(
  8.             self, asset_price, asset_volatility, strike_price,
  9.             time_to_expiration, risk_free_rate
  10.     ):
  11.         b = math.exp(-risk_free_rate * time_to_expiration)
  12.         x1 = math.log((b * strike_price) / asset_price) + .5 * (
  13.                     asset_volatility * asset_volatility) * time_to_expiration
  14.         x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  15.         z1 = norm.cdf(x1)
  16.         z1 = b * strike_price * z1
  17.         x2 = math.log((b * strike_price) / asset_price) - .5 * (
  18.                     asset_volatility * asset_volatility) * time_to_expiration
  19.         x2 = x2 / (asset_volatility * (time_to_expiration ** .5))
  20.         z2 = norm.cdf(x2)
  21.         z2 = asset_price * z2
  22.         return z1 - z2
  24.     def __init__(
  25.             self, asset_price, asset_volatility, strike_price,
  26.             time_to_expiration, risk_free_rate
  27.     ):
  28.         self.asset_price = asset_price
  29.         self.asset_volatility = asset_volatility
  30.         self.strike_price = strike_price
  31.         self.time_to_expiration = time_to_expiration
  32.         self.risk_free_rate = risk_free_rate
  33.         self.price = self.put_price(asset_price, asset_volatility, strike_price, time_to_expiration, risk_free_rate)

Greeks

Using a Taylor series expansion we can derive all the greeks.
The greeks tell us how we can expect an option or portfolio of options to change when a change occurs in one or more of the option exposures.
Something important to note is that all first-order approximations are linear, and the option pricing function is non-linear.
This means the more the underlying parameter deviates from the initial partial-derivative calculation the less accurate it will be.

Delta

Delta is the first-order-partial derivative with respect to the underlying asset of the BS model.
Delta refers to how the option value changes when there is a change in the underlying asset price.
The following code is part of the ../src/utils.py:

  1. # Call delta
  2. def call_delta(
  3.         self, asset_price, asset_volatility, strike_price,
  4.         time_to_expiration, risk_free_rate
  5. ):
  6.     b = math.exp(-risk_free_rate * time_to_expiration)
  7.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  8.             asset_volatility * asset_volatility) * time_to_expiration
  9.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  10.     z1 = norm.cdf(x1)
  11.     return z1
  13. # Put delta
  14. def put_delta(
  15.         self, asset_price, asset_volatility, strike_price,
  16.         time_to_expiration, risk_free_rate
  17. ):
  18.     b = math.exp(-risk_free_rate * time_to_expiration)
  19.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  20.             asset_volatility * asset_volatility) * time_to_expiration
  21.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  22.     z1 = norm.cdf(x1)
  23.     return z1 - 1

Gamma

Gamma is the second-order-partial-derivative with respect to the underlying of the BS model.
Gamma refers to how the option’s delta changes when there is a change in the underlying asset price.
The following code is part of the ../src/utils.py:

  1. # Call gamma
  2. def call_gamma(
  3.         self, asset_price, asset_volatility, strike_price,
  4.         time_to_expiration, risk_free_rate
  5. ):
  6.     b = math.exp(-risk_free_rate * time_to_expiration)
  7.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  8.             asset_volatility * asset_volatility) * time_to_expiration
  9.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  10.     z1 = norm.cdf(x1)
  11.     z2 = z1 / (asset_price * asset_volatility * math.sqrt(time_to_expiration))
  12.     return z2
  14. # Put gamma
  15. def put_gamma(
  16.         self, asset_price, asset_volatility, strike_price,
  17.         time_to_expiration, risk_free_rate
  18. ):
  19.     b = math.exp(-risk_free_rate * time_to_expiration)
  20.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  21.             asset_volatility * asset_volatility) * time_to_expiration
  22.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  23.     z1 = norm.cdf(x1)
  24.     z2 = z1 / (asset_price * asset_volatility * math.sqrt(time_to_expiration))
  25.     return z2

Vega

Vega is the first-order-partial-derivative with respect to the underlying asset volatility of the BS model.
Vega refers to how the option value changes when there is a change in the underlying asset volatility.
The following code is part of the ../src/utils.py:

  1. # Call vega
  2. def call_vega(
  3.         self, asset_price, asset_volatility, strike_price,
  4.         time_to_expiration, risk_free_rate
  5. ):
  6.     b = math.exp(-risk_free_rate * time_to_expiration)
  7.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  8.             asset_volatility * asset_volatility) * time_to_expiration
  9.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  10.     z1 = norm.cdf(x1)
  11.     z2 = asset_price * z1 * math.sqrt(time_to_expiration)
  12.     return z2 / 100
  14. # Put vega
  15. def put_vega(
  16.         self, asset_price, asset_volatility, strike_price,
  17.         time_to_expiration, risk_free_rate
  18. ):
  19.     b = math.exp(-risk_free_rate * time_to_expiration)
  20.     x1 = math.log(asset_price / (b * strike_price)) + .5 * (
  21.             asset_volatility * asset_volatility) * time_to_expiration
  22.     x1 = x1 / (asset_volatility * (time_to_expiration ** .5))
  23.     z1 = norm.cdf(x1)
  24.     z2 = asset_price * z1 * math.sqrt(time_to_expiration)
  25.     return z2 / 100

Theta

Theta is the first-oder-partial-derivative with respect to the time until option expiration of the BS model.
Theta refers to how the option value changes as time passes.

Rho

Rho is the first-order-partial-derivative with respect to the risk-free rate of the BS model.
Rho refers to how the option value changes as the interest rate changes.

Dynamic Hedging

The first thing to realize is that to neutralize exposure to greeks we are going to need offsetting positions in other options.
There are three greeks to neutralize, so we need three options to create three equations of greeks and weights with three unknowns (the weights in the other tradable options).

However, the trick here is realizing that the partial derivative of the underlying asset with respect to itself is just 1, this means the underlying asset has a delta of 1 and all other greek values are 0.
This means we can construct a portfolio of two tradable options, find appropriate weights to neutralize the greeks, then take an offsetting position in the underlying asset — effectively neutralizing exposure to all three greeks.

Portfolio position

To neutralize the portfolio it’s important at first understanding the overall position.
running the code in ../deliverables/asset_allocation.py it is first shown the initial portfolio position

  1. from src.utils import *
  2. from src.variables import *
  4. # Portfolio position
  5. option1 = EuropeanCall(asset_price=asset_price, 
  6.                        asset_volatility=sigma, 
  7.                        strike_price=K1, 
  8.                        time_to_expiration=dt,
  9.                        risk_free_rate=rf)
  11. # theoretical value of the position
  12. print('Theoretical Initial Portfolio value: ', str(option1.price * abs(nContract1)))
  14. # greeks
  15. print('Initial Portfolio Greeks:\n '
  16.       'Delta: {}\n '
  17.       'Gamma: {}\n '
  18.       'Vega: {}'.format(option1.delta * nContract1,
  19.                         option1.gamma * nContract1,
  20.                         option1.vega * nContract1))

and then the output will be:

  1. >>> Theoretical Initial Portfolio value:  32264.05329034736
  2. >>> Initial Portfolio Greeks:
  3.  Delta: -523.8788365375873
  4.  Gamma: -6.3495209433350475
  5.  Vega: -815.5392717775394

Greek neutralization

The greeks we are interested in neutralizing in the current portfolio can be expressed as a vector:

equation

The goal is to find the weights of the three assets we are capable of trading to neutralize these values.
First, we will look to neutralize gamma and vega, then using the underlying asset, we will neutralize delta.

equation

This means by inverting the matrix containing the greek values for the tradable options we can find the appropriate weights.
equation

this is the code at ../deliverables/asset-allocation.py:

  1. from src.utils import *
  2. from src.variables import *
  3. import numpy as np
  5. # Price option2 and option3 and find the greeks
  6. option2 = EuropeanCall(asset_price=asset_price, 
  7.                        asset_volatility=sigma, 
  8.                        strike_price=K2, 
  9.                        time_to_expiration=dt, 
  10.                        risk_free_rate=rf)
  12. option3 = EuropeanCall(asset_price=asset_price, 
  13.                        asset_volatility=sigma, 
  14.                        strike_price=K3, 
  15.                        time_to_expiration=dt, 
  16.                        risk_free_rate=rf)
  18. # greek neutralization -- gamma and vega
  19. greeks = np.array([[option2.gamma, option3.gamma], [option2.vega, option3.vega]])
  20. portfolio_greeks = [[option1.gamma * abs(nContract1)], [option1.vega * abs(nContract1)]]
  21. inv = np.linalg.inv(np.round(greeks, 2))  # We need to round otherwise we can end up with a non-invertible matrix
  23. # position on option 2 and 3 to be gamma and vega neutral
  24. w = np.dot(inv, portfolio_greeks)

Now that the exposure to gamma and vega is neutralized we need to neutralize our new exposure to delta.
To find our new exposure, we take the sum-product of all option positions in our portfolio with their respective deltas.

this is the code at ../deliverables/asset-allocation.py:

  1. # Greeks including delta
  2. portfolio_greeks = [[option1.delta * nContract1], [option1.gamma * nContract1], [option1.vega * nContract1]]
  3. greeks = np.array([[option2.delta, option3.delta], [option2.gamma, option3.gamma], [option2.vega, option3.vega]])
  4. w_stock = (np.round(np.dot(np.round(greeks, 2), w) + portfolio_greeks))[0]

Final Delta, Gamma, and Vega Neutral Portfolio

the final positions are the following:

  1. >>> Final asset allocation: 
  2.  option1: -1000
  3.  option2: 8641
  4.  option3: -8006
  5.  underlying asset: -46

Conclusion

In this project, I’ve learned how to build Delta, Gamma and Vega neutral Portfolio to hedge the exposure against changes in volatility, movements in the underlying asset and the speed of movements in the underlying asset.
The code can be implemented directly into a live trading system in order to actively hedge the portfolio position day by day.
Hedging all Greek letters may require option positions greater than the original position.
Because of the limitations (instantaneous, local measures, model risk) of Greek letter hedging, this may rather increase than decrease risk.

The material discussed in this project it’s not financial advice.

Supported versions

This configuration has been tested against Python 3.8