def implied_vol(prices,
strikes,
expiries,
spots=None,
forwards=None,
discount_factors=None,
is_call_options=None,
method=ImpliedVolMethod.NEWTON,
validate_args=False,
dtype=None,
name=None,
**kwargs):
"""Finds the implied volatilities of options under the Black Scholes model.
#### Examples
```python
forwards = np.array([1.0, 1.0, 1.0, 1.0])
strikes = np.array([1.0, 2.0, 1.0, 0.5])
expiries = np.array([1.0, 1.0, 1.0, 1.0])
discount_factors = np.array([1.0, 1.0, 1.0, 1.0])
option_signs = np.array([1.0, 1.0, -1.0, -1.0])
volatilities = np.array([1.0, 1.0, 1.0, 1.0])
prices = black_scholes.option_price(
forwards,
strikes,
volatilities,
expiries,
discount_factors=discount_factors,
is_call_options=is_call_options)
implied_vols = newton_vol.implied_vol(forwards,
strikes,
expiries,
discount_factors,
prices,
option_signs)
with tf.Session() as session:
print(session.run(implied_vols[0]))
# Expected output:
# [ 1. 1. 1. 1.]
Args:
prices: A real `Tensor` of any shape. The prices of the options whose
implied vol is to be calculated.
strikes: A real `Tensor` of the same dtype as `prices` and a shape that
broadcasts with `prices`. The strikes of the options.
expiries: A real `Tensor` of the same dtype as `prices` and a shape that
broadcasts with `prices`. The expiry for each option. The units should be
such that `expiry * volatility**2` is dimensionless.
spots: A real `Tensor` of any shape that broadcasts to the shape of the
`prices`. The current spot price of the underlying. Either this argument
or the `forwards` (but not both) must be supplied.
forwards: A real `Tensor` of any shape that broadcasts to the shape of
`prices`. The forwards to maturity. Either this argument or the `spots`
must be supplied but both must not be supplied.
discount_factors: An optional real `Tensor` of same dtype as the `prices`.
If not None, these are the discount factors to expiry (i.e. e^(-rT)). If
None, no discounting is applied (i.e. it is assumed that the undiscounted
option prices are provided ). If `spots` is supplied and
`discount_factors` is not None then this is also used to compute the
forwards to expiry.
Default value: None, equivalent to discount factors = 1.
is_call_options: A boolean `Tensor` of a shape compatible with `prices`.
Indicates whether the option is a call (if True) or a put (if False). If
not supplied, call options are assumed.
method: Enum value of ImpliedVolMethod to select the algorithm to use to
infer the implied volatility.
validate_args: A Python bool. If True, indicates that arguments should be
checked for correctness before performing the computation. The checks
performed are: (1) Forwards and strikes are positive. (2) The prices
satisfy the arbitrage bounds (i.e. for call options, checks the
inequality `max(F-K, 0) <= Price <= F` and for put options, checks that
`max(K-F, 0) <= Price <= K`.). (3) Checks that the prices are not too
close to the bounds. It is numerically unstable to compute the implied
vols from options too far in the money or out of the money.
dtype: `tf.Dtype` to use when converting arguments to `Tensor`s. If not
supplied, the default TensorFlow conversion will take place. Note that
this argument does not do any casting for `Tensor`s or numpy arrays.
Default value: None.
name: (Optional) Python str. The name prefixed to the ops created by this
function. If not supplied, the default name 'implied_vol' is used.
Default value: None
**kwargs: Any other keyword arguments to be passed to the specific
implementation. (See black_scholes.implied_vol_approx and
black_scholes.implied_vol_newton for details).
Returns:
implied_vols: A `Tensor` of the same dtype as `prices` and shape as the
common broadcasted shape of `(prices, spots/forwards, strikes, expiries)`.
The implied volatilities as inferred by the chosen method.
Raises:
ValueError: If both `forwards` and `spots` are supplied or if neither is
supplied.
"""
if method == ImpliedVolMethod.FAST_APPROX:
return approx.implied_vol(prices,
strikes,
expiries,
spots=spots,
forwards=forwards,
discount_factors=discount_factors,
is_call_options=is_call_options,
validate_args=validate_args,
dtype=dtype,
name=name,
**kwargs)
if method == ImpliedVolMethod.NEWTON:
return newton.implied_vol(prices,
strikes,
expiries,
spots=spots,
forwards=forwards,
discount_factors=discount_factors,
is_call_options=is_call_options,
validate_args=validate_args,
dtype=dtype,
name=name,
**kwargs)[0]
raise ValueError('Unknown implied vol method {}'.format(method))
def implied_vol(
*,
prices,
strikes,
expiries,
spots=None,
forwards=None,
discount_factors=None,
is_call_options=None,
initial_volatilities=None,
underlying_distribution=utils.UnderlyingDistribution.LOG_NORMAL,
tolerance=1e-8,
max_iterations=20,
validate_args=False,
dtype=None,
name=None):
"""Computes implied volatilities from given call or put option prices.
This method applies a Newton root search algorithm to back out the implied
volatility given the price of either a put or a call option.
The implementation assumes that each cell in the supplied tensors corresponds
to an independent volatility to find.
Args:
prices: A real `Tensor` of any shape. The prices of the options whose
implied vol is to be calculated.
strikes: A real `Tensor` of the same dtype as `prices` and a shape that
broadcasts with `prices`. The strikes of the options.
expiries: A real `Tensor` of the same dtype as `prices` and a shape that
broadcasts with `prices`. The expiry for each option. The units should be
such that `expiry * volatility**2` is dimensionless.
spots: A real `Tensor` of any shape that broadcasts to the shape of the
`prices`. The current spot price of the underlying. Either this argument
or the `forwards` (but not both) must be supplied.
Default value: None.
forwards: A real `Tensor` of any shape that broadcasts to the shape of
`prices`. The forwards to maturity. Either this argument or the `spots`
must be supplied but both must not be supplied.
Default value: None.
discount_factors: An optional real `Tensor` of same dtype as the `prices`.
If not None, these are the discount factors to expiry (i.e. e^(-rT)). If
None, no discounting is applied (i.e. it is assumed that the undiscounted
option prices are provided ). If `spots` is supplied and
`discount_factors` is not None then this is also used to compute the
forwards to expiry.
Default value: None, equivalent to discount factors = 1.
is_call_options: A boolean `Tensor` of a shape compatible with `prices`.
Indicates whether the option is a call (if True) or a put (if False). If
not supplied, call options are assumed.
Default value: None.
initial_volatilities: A real `Tensor` of the same shape and dtype as
`forwards`. The starting positions for Newton's method.
Default value: None. If not supplied, the starting point is chosen using
the Stefanica-Radoicic scheme. See `polya_approx.implied_vol` for
details.
Default value: None.
underlying_distribution: Enum value of ImpliedVolUnderlyingDistribution to
select the distribution of the underlying.
Default value: UnderlyingDistribution.LOG_NORMAL
tolerance: `float`. The root finder will stop where this tolerance is
crossed.
max_iterations: `int`. The maximum number of iterations of Newton's method.
Default value: 20.
validate_args: A Python bool. If True, indicates that arguments should be
checked for correctness before performing the computation. The checks
performed are: (1) Forwards and strikes are positive. (2) The prices
satisfy the arbitrage bounds (i.e. for call options, checks the
inequality `max(F-K, 0) <= Price <= F` and for put options, checks that
`max(K-F, 0) <= Price <= K`.). (3) Checks that the prices are not too
close to the bounds. It is numerically unstable to compute the implied
vols from options too far in the money or out of the money.
Default value: False.
dtype: `tf.Dtype` to use when converting arguments to `Tensor`s. If not
supplied, the default TensorFlow conversion will take place. Note that
this argument does not do any casting for `Tensor`s or numpy arrays.
Default value: None.
name: (Optional) Python str. The name prefixed to the ops created by this
function. If not supplied, the default name 'implied_vol' is used.
Default value: None.
Returns:
A 3-tuple containing the following items in order:
(a) implied_vols: A `Tensor` of the same dtype as `prices` and shape as
the common broadcasted shape of
`(prices, spots/forwards, strikes, expiries)`. The implied vols as
inferred by the algorithm. It is possible that the search may not have
converged or may have produced NaNs. This can be checked for using the
following return values.
(b) converged: A boolean `Tensor` of the same shape as `implied_vols`
above. Indicates whether the corresponding vol has converged to within
tolerance.
(c) failed: A boolean `Tensor` of the same shape as `implied_vols` above.
Indicates whether the corresponding vol is NaN or not a finite number.
Note that converged being True implies that failed will be false.
However, it may happen that converged is False but failed is not True.
This indicates the search did not converge in the permitted number of
iterations but may converge if the iterations are increased.
Raises:
ValueError: If both `forwards` and `spots` are supplied or if neither is
supplied.
"""
if (spots is None) == (forwards is None):
raise ValueError(
'Either spots or forwards must be supplied but not both.')
with tf.compat.v1.name_scope(name,
default_name='implied_vol',
values=[
prices, spots, forwards, strikes,
expiries, discount_factors,
is_call_options, initial_volatilities
]):
prices = tf.convert_to_tensor(prices, dtype=dtype, name='prices')
dtype = prices.dtype
strikes = tf.convert_to_tensor(strikes, dtype=dtype, name='strikes')
expiries = tf.convert_to_tensor(expiries, dtype=dtype, name='expiries')
if discount_factors is None:
discount_factors = tf.convert_to_tensor(1.0,
dtype=dtype,
name='discount_factors')
else:
discount_factors = tf.convert_to_tensor(discount_factors,
dtype=dtype,
name='discount_factors')
if forwards is not None:
forwards = tf.convert_to_tensor(forwards,
dtype=dtype,
name='forwards')
else:
spots = tf.convert_to_tensor(spots, dtype=dtype, name='spots')
forwards = spots / discount_factors
if initial_volatilities is None:
if underlying_distribution is utils.UnderlyingDistribution.LOG_NORMAL:
initial_volatilities = approx.implied_vol(
prices=prices,
strikes=strikes,
expiries=expiries,
forwards=forwards,
discount_factors=discount_factors,
is_call_options=is_call_options,
validate_args=validate_args)
elif underlying_distribution is utils.UnderlyingDistribution.NORMAL:
initial_volatilities = prices / _NORM_PDF_AT_ZERO
else:
initial_volatilities = tf.convert_to_tensor(
initial_volatilities, dtype=dtype, name='initial_volatilities')
implied_vols, converged, failed = _newton_implied_vol(
prices, strikes, expiries, forwards, discount_factors,
is_call_options, initial_volatilities, underlying_distribution,
tolerance, max_iterations)
return implied_vols, converged, failed