BermudanTensorFlow.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pricing Exotic Options with TensorFlow\n",
    "\n",
    "Bermudan Options "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/anaconda/lib/python3.6/site-packages/h5py/__init__.py:34: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import tensorflow as tf\n",
    "import scipy.stats as stats\n",
    "from sklearn.linear_model import LinearRegression\n",
    "from sklearn.metrics import mean_squared_error\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_continuation_function():\n",
    "    X = tf.placeholder(tf.float32, (None, 3))\n",
    "    y = tf.placeholder(tf.float32, (None, 1))\n",
    "    w = tf.Variable(initial_value=tf.random_normal((3,1))*0.1)\n",
    "    b = tf.Variable(initial_value=tf.ones(1)*1)\n",
    "    y_hat = tf.add(tf.matmul(X,w), b)\n",
    "    pre_error = tf.pow(y-y_hat,2)\n",
    "    error = tf.reduce_mean(pre_error)\n",
    "    train = tf.train.AdamOptimizer(0.1).minimize(error)\n",
    "    return(X, y, train, w, b, y_hat)\n",
    "\n",
    "def feature_matrix_from_current_state(state):\n",
    "    feature_0 = tf.pow(state,0)\n",
    "\n",
    "    feature_1 = tf.pow(state,1)\n",
    "    feature_1_mean = tf.reduce_mean(feature_1)\n",
    "    feature_1_std = tf.sqrt(tf.reduce_sum(tf.square(feature_1 - feature_1_mean))/(N_samples_pricing+1))\n",
    "    feature_1_norm = (feature_1 - feature_1_mean) / feature_1_std\n",
    "\n",
    "\n",
    "    feature_2 = 2*tf.pow(state,2)-1\n",
    "    feature_2_mean = tf.reduce_mean(feature_2)\n",
    "    feature_2_std = tf.sqrt(tf.reduce_sum(tf.square(feature_2 - feature_2_mean))/(N_samples_pricing+1))\n",
    "    feature_2_norm = (feature_2 - feature_2_mean) / feature_2_std\n",
    "\n",
    "    feature_3 = 4*tf.pow(state,3)-3*feature_1\n",
    "    feature_3_mean = tf.reduce_mean(feature_3)\n",
    "    feature_3_std = tf.sqrt(tf.reduce_sum(tf.square(feature_3 - feature_3_mean))/(N_samples_pricing+1))\n",
    "    feature_3_norm = (feature_3 - feature_3_mean) / feature_3_std\n",
    "\n",
    "    features = tf.concat([feature_1_norm, feature_2_norm, feature_3_norm], axis=0)\n",
    "    features = tf.reshape(features, shape=(3, N_samples_pricing))\n",
    "    features = tf.transpose(features)\n",
    "    return features\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def pricing_function(number_call_dates):\n",
    "    S = tf.placeholder(tf.float32)\n",
    "    # First excerise date\n",
    "    dts = tf.placeholder(tf.float32)\n",
    "    # 2nd exersice date\n",
    "    K = tf.placeholder(tf.float32)\n",
    "    r = tf.placeholder(tf.float32)\n",
    "    sigma = tf.placeholder(tf.float32)\n",
    "    dW = tf.placeholder(tf.float32)\n",
    "    \n",
    "    S_t = S * tf.cumprod(tf.exp((r-sigma**2/2)*dts + sigma*tf.sqrt(dts)*dW), axis=1)\n",
    "    \n",
    "    E_t = tf.exp(-r*tf.cumsum(dts))*tf.maximum(S_t-K, 0)\n",
    "\n",
    "    \n",
    "    continuationValues = []\n",
    "    training_functions = []\n",
    "    \n",
    "    previous_exersies = 0\n",
    "    npv = 0\n",
    "    for i in range(number_call_dates-1):\n",
    "        (input_x, input_y, train, w, b, y_hat) = get_continuation_function()\n",
    "        training_functions.append((input_x, input_y, train, w, b, y_hat))\n",
    "        X = feature_matrix_from_current_state(S_t[:, i])\n",
    "        contValue = tf.add(tf.matmul(X, w),b)\n",
    "        continuationValues.append(contValue)\n",
    "        inMoney = tf.cast(tf.greater(E_t[:,i], 0.), tf.float32)\n",
    "        exercise = tf.cast(tf.greater(E_t[:,i], contValue[:,0]), tf.float32) * inMoney * (1-previous_exersies)\n",
    "        previous_exersies += exercise\n",
    "        npv += exercise*E_t[:,i]\n",
    "    \n",
    "    # Last exercise date\n",
    "    inMoney = tf.cast(tf.greater(E_t[:,-1], 0.), tf.float32)\n",
    "    exercise =  inMoney * (1-previous_exersies)\n",
    "    npv += exercise*E_t[:,-1]\n",
    "    npv = tf.reduce_mean(npv)\n",
    "    greeks = tf.gradients(npv, [S, r, sigma])\n",
    "    return([S, dts, K, r, sigma, dW, S_t, E_t, npv, greeks, training_functions])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def bermudanMC_tensorFlow(S_0, strike, exTimes, impliedvol, riskfree_r, random_train, random_pricing):\n",
    "    n_excerises = len(exTimes)\n",
    "    with tf.Session() as sess:\n",
    "        \n",
    "        S, dts, K, r, sigma, dW, S_t, E_t, npv, greeks, training_functions= pricing_function(n_excerises)\n",
    "        sess.run(tf.global_variables_initializer())\n",
    "        paths, exercise_values = sess.run([S_t, E_t], {\n",
    "            S: S_0,\n",
    "            dts : exTimes,\n",
    "            K : strike,\n",
    "            r : riskfree_r,\n",
    "            sigma: impliedvol,\n",
    "            dW : random_train\n",
    "        })    \n",
    "        \n",
    "        for i in range(n_excerises-1)[::-1]:\n",
    "            (input_x, input_y, train, w, b, y_hat) = training_functions[i]\n",
    "            y = exercise_values[:, i+1:i+2]\n",
    "            X = paths[:, i]\n",
    "            X = np.c_[X**1, 2*X**2-1, 4*X**3 - 3 * X]\n",
    "            X = (X - np.mean(X, axis=0)) / np.std(X, axis=0)\n",
    "            for epoch in range(80):\n",
    "                _ = sess.run(train, {input_x:X[exercise_values[:,i]>0], \n",
    "                                     input_y:y[exercise_values[:,i]>0]})\n",
    "            cont_value = sess.run(y_hat, {input_x:X, \n",
    "                                     input_y:y})\n",
    "            exercise_values[:, i+1:i+2] = np.maximum(exercise_values[:, i+1:i+2], cont_value)\n",
    "        \n",
    "        npv, greeks = sess.run([npv, greeks], { S: S_0,\n",
    "                                                dts : exTimes,\n",
    "                                                K : strike,\n",
    "                                                r : riskfree_r,\n",
    "                                                sigma: impliedvol,\n",
    "                                                dW : N_pricing\n",
    "                                              })\n",
    "        return(npv, greeks)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "N_samples_learn = 10000\n",
    "N_samples_pricing = 100000\n",
    "calldates = 2\n",
    "np.random.seed(42)\n",
    "N = np.random.randn(N_samples_learn,calldates)\n",
    "N_pricing = np.random.randn(N_samples_pricing,calldates)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9.751283, [0.5057875, 81.654884, 56.51146])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bermudanMC_tensorFlow(100., 110., [1., 1.], 0.2, 0.03, N, N_pricing)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}