Pricing Options and Computing Implied Volatilities using Neural Networks, strange shape of a graph

Question

I am sometimes confused by the expression moneyness. Can anyone tell me what is plot here ? Its from the paper called :Pricing Options and Computing Implied Volatilities using Neural Networks.

Usually, I see the volatility as a function of the shape like the negative of a sigmoid (inversed S). Here the shape is differnet. Is it the curve of the price against $\frac {X_0} {K} $ ?

Is it common to plot like that ? What about a plot against $\frac {K} {X_0} $

Answer 1

As mentioned, the moneyness refers to the ratio of stock price to strike price, that is, $\frac{S}{K}.$.

I reproduce the following plots using Python 3.

Comparing the plot above to the plot in the paper, they exhibit fairly similar behaviors except at zero volatility (I get divide by zero error).

The source codes are as follows and can be found at my github:

from Option import *
import numpy as np
import matplotlib.pyplot as plt

sigma_upper = 10
x = np.linspace(1, sigma_upper, sigma_upper)

d = 0
r = 0
T = 1
sigma = 0.1
K = 1

moneyness = np.arange(0.7, 1.4, 0.1)

for i in moneyness[::-1]:
  S = i * K
  y = [Option(S, K, r, d, sigma, T).european_call() for sigma in range(1, sigma_upper+1)]
  plt.plot(x,y, label = 'moneyness = ' + str(round(i,2)))
  plt.xlabel('Volatility')
  plt.ylabel('Option Price')
  plt.legend();

The Option script source is as follows and can be found at my github (I extracted only the necessary parts):

from scipy.stats import norm

class Option:
    def __init__(self, S, K, r, d, sigma, T):
        '''
        Parameters:
        ===========
        S: stock price 
        K: strike price
        r: risk-free interest rate
        d: dividend 
        sigma: volatility (implied)
        T: time to maturity


        Returns: 
        ===========
        Forward price, vanilla European call and put option' prices, cash-or-nothing call and put options' prices,
        zero coupon bond and forward contract.
        '''

        self.S = S
        self.K = K
        self.r = r
        self.d = d
        self.sigma = sigma
        self.T = T

        self.d1 = (np.log(self.S/self.K) + (self.r - self.d + self.sigma**2 / 2) * self.T) / (self.sigma * np.sqrt(self.T))
        self.d2 = self.d1 - self.sigma * np.sqrt(self.T)

    def european_call(self):
        '''
        output vanilla European call option's price using Black-Scholes formula 
        '''        
        return self.S * np.exp(-self.d * self.T) * norm.cdf(self.d1) - self.K * np.exp(-self.r * self.T)*norm.cdf(self.d2)