In [0]:

    

#@title Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.


    

In [0]:

    

#Notebook Imports
import tensorflow as tf
assert tf.__version__.startswith('2')
import tensorflow_probability as tfp 
import numpy as np
import scipy.stats as stats
import matplotlib.pyplot as plt


    

In [0]:

    

print( tf.__version__)


    

In [0]:

    

#Formula Variables
stock_price = 50.
strike_price = 55.
time_to_expire = 0.25
implied_volitility = 0.2
risk_free_rate_of_return = 0.02
seed = 187


    

In [0]:

    

def blackscholes(stockPrice, strike, time_to_expr, imp_vol, risk_free):
    #S: Stock Price
    #K: Strike Price
    #T: Time to Maturity
    #Sigma: Volatility of underlying asset
    #r: Interest Rate
    
    S = stockPrice
    K = strike
    T = time_to_expr
    sigma = imp_vol
    r = risk_free
    
    d_1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    d_2 = (np.log(S / K) + (r - 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))
    return (S * stats.norm.cdf(d_1, 0.0, 1.0) - K * np.exp(-r * T) * stats.norm.cdf(d_2,0.0,1.0))


    

In [0]:

    

blackscholes(stock_price,strike_price,time_to_expire,implied_volitility,risk_free_rate_of_return)


    

In [0]:

    

def blackscholes_tf2(stockPrice, strike, time_to_expr, imp_vol, risk_free, show_greeks = True):
    #Formulas using TensorFlow libraries instead of numpy
    d_1 = (tf.math.log(stockPrice / strike) + (risk_free + 0.5 * imp_vol ** 2) * time_to_expr) / (imp_vol * tf.sqrt(time_to_expr))
    d_2 = (tf.math.log(stockPrice / strike) + (risk_free - 0.5 * imp_vol ** 2) * time_to_expr) / (imp_vol * tf.sqrt(time_to_expr))
    target_calc = stockPrice * tfp.distributions.Normal(0.,1.).cdf(d_1) - strike * tf.exp(-risk_free * time_to_expr) * tfp.distributions.Normal(0.,1.).cdf(d_2)
    return target_calc


    

In [0]:

    

bs_tf = tf.function(blackscholes_tf2)
bs_tf(stock_price,strike_price,time_to_expire,implied_volitility,risk_free_rate_of_return).numpy()


    

In [0]:

    

def black_scholes_formula(stockPrice, strike, time_to_expr, imp_vol, risk_free, timedelta, stdnorm_random_variates):
    return stockPrice * tf.math.cumprod(tf.exp((risk_free - 0.5 * imp_vol ** 2) * timedelta + imp_vol * tf.sqrt(timedelta) * stdnorm_random_variates), axis = 1)


    

In [0]:

    

def make_path_simulator(stockPrice, strike, time_to_expr, imp_vol, risk_free, seed, n_sims, obs):
    #Create the time variables
    if seed != 0:
        np.random.seed(seed)
    stdnorm_random_variates = np.random.randn(n_sims, obs)
    timedelta = time_to_expr / stdnorm_random_variates.shape[1]
    return black_scholes_formula(stockPrice, strike, 
                                 time_to_expr, imp_vol, risk_free, timedelta, stdnorm_random_variates)


    

In [0]:

    

path_simulator = tf.function(make_path_simulator)
paths = path_simulator(stock_price,strike_price,
                       time_to_expire,implied_volitility,risk_free_rate_of_return, seed, 10, 400)
plt.figure(figsize=(8,5))
_ = plt.plot(np.transpose(paths))
_ = plt.title('Simulated Path')
_ = plt.ylabel('Price')
_ = plt.xlabel('TimeStep')
plt.show()


    

In [0]:

    

#Check if the expected value of the simulation is close to the expected mean
path_simulator = tf.function(make_path_simulator)
paths = path_simulator(stock_price,strike_price,
                       time_to_expire,implied_volitility,risk_free_rate_of_return, seed, 10000000, 2)
assert np.mean(paths[:, 1])-np.exp(0.03*2)*100<0.01,'Value is too large'


    

In [0]:

    

def create_plain_vanilla_mc_tf_pricer(stockPrice, strike, time_to_expr, imp_vol, risk_free, seed, n_sims, obs):
    if seed != 0:
        np.random.seed(seed)
    stdnorm_random_variates = np.random.randn(n_sims, 1)
    timedelta = time_to_expr / stdnorm_random_variates.shape[1]
    S_T = black_scholes_formula(stockPrice, strike, time_to_expr, imp_vol, risk_free, timedelta, stdnorm_random_variates)
    payout = tf.maximum(S_T[:,-1] - strike, 0)
    npv = tf.exp(-risk_free*time_to_expr) * tf.reduce_mean(payout)
    target_calc = npv
    return target_calc


    

In [0]:

    

sims = 1000000
observations = 1

plain_vanilla_mc_tf_pricer = tf.function(create_plain_vanilla_mc_tf_pricer)
plain_vanilla_mc_tf_pricer(stock_price,strike_price,time_to_expire,implied_volitility,risk_free_rate_of_return, seed, sims,observations).numpy()