Iron_Condor_v08_option-spread_bunch-forecast.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Notebook for training for short spreads with bunch forecast\n",
    "Forecast for last 10% of data. Forecast is done in one go.\n",
    "- Sequential model\n",
    "- LSTM model\n",
    "- not stationary\n",
    "- bunch forecast"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Using TensorFlow backend.\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib import cm\n",
    "import numpy as np\n",
    "import scipy.stats as si\n",
    "from IPython.display import Image\n",
    "import datetime\n",
    "import time\n",
    "\n",
    "from keras.models import Sequential\n",
    "from keras.layers.core import Dense, Activation, Dropout\n",
    "from keras.layers import LSTM\n",
    "from sklearn import preprocessing, metrics\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup = pd.HDFStore('backup_v08.h5')\n",
    "#df = backup['df']\n",
    "#unscaled_seq_predictions = backup['unscaled_seq_predictions']\n",
    "#unscaled_data = backup['unscaled_data']\n",
    "#unscaled_lstm_predictions = backup['unscaled_lstm_predictions']\n",
    "#test_data_unscaled = backup['test_data_unscaled']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Iron Condor\n",
    "The iron condor is a investment strategy using four option with the same strike date. More precise, the iron condor uses two vertical spreads, one put spread and a call spread. The put spread consists at of a short put option (P_s) with a strike price below the actual stock price and a long put option (P_l) with a strike price below the short put option P_s. The call spread consists of a short call option (C_s) above the actual stock price and a long call option (C_l) above the short call option C_s. All options have the same strike date and the spread on both legs can vary but is chosen mostly the same.\n",
    "![title](Condor_strategy.png)\n",
    "\"A trader who buys an iron condor speculates that the spot price of the underlying instrument will be between the short strikes when the options expire where the position is the most profitable. Thus, the iron condor is an options strategy considered when the trader has a neutral outlook for the market. Buying iron condors are popular with traders who seek regular income from their trading capital. An iron condor buyer will attempt to construct the trade so that the short strikes are close enough that the position will earn a desirable net credit, but wide enough apart so that it is likely that the spot price of the underlying will remain between the short strikes for the duration of the options contract. The trader would typically play iron condors every month (if possible) thus generating monthly income with the strategy.\" [https://en.wikipedia.org/wiki/Iron_condor]\n",
    "\n",
    "### Goal of the project\n",
    "The goal of the project is to find a strategy to maximise the profit with an iron condor. The ideal short and long spreads should be found at any time based on data of the underlying stock and of the indices S&P500 and Nasdaq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_data(var_name,name):\n",
    "    # reads in csv into DataFrame, keeps Adj Close and Volume and calculates rolling averages and \n",
    "    # rolling standard deviation of Adj Close for 4, 9 and 18 days\n",
    "    # var_name: path to csv file\n",
    "    # name: name of the column df\n",
    "    df = pd.read_csv('data/'+var_name+'.csv',index_col='Date', parse_dates=True)\n",
    "    df.rename(columns={\"Adj Close\": name, \"Volume\": name+'_volume', \"Open\": name+'_open'}, inplace = True)\n",
    "    df.rename(columns={\"High\": name+'_high', \"Low\": name+'_low', \"Close\": name+'_close'}, inplace = True)\n",
    "    #df.drop(['Open','High','Low','Close'],axis=1, inplace = True)\n",
    "    #if name == 'google':\n",
    "        #df['google_45d'] = df['google'].shift(-32) # stock price in 45 days (approx. 32 trading days)\n",
    "    df[name+'_ra_04'] = df[name].rolling('4d').mean()\n",
    "    df[name+'_std_04'] = df[name].rolling('4d').std()\n",
    "    df[name+'_ra_09'] = df[name].rolling('9d').mean()\n",
    "    df[name+'_std_09'] = df[name].rolling('9d').std()\n",
    "    df[name+'_ra_18'] = df[name].rolling('18d').mean()\n",
    "    df[name+'_std_18'] = df[name].rolling('18d').std()\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sigma_fct(df, name, days = 10):\n",
    "    # For Black-Scholes I need the volatility of return of the underlying assets in the last days\n",
    "    # based on https://www.wikihow.com/Calculate-Historical-Stock-Volatility\n",
    "    # First the ln of daily returns is calculated for each element of names\n",
    "    for name in names:\n",
    "        a=pd.DataFrame()\n",
    "        a['ln_daily_return'] = np.log(df[name] / df[name].shift(1))\n",
    "        # next the rolling average (mean) over certain days is calculated\n",
    "        a['rol_avg'] =  a['ln_daily_return'].rolling(str(days)+'d').mean()\n",
    "        # next deviation from the mean is calculated\n",
    "        a['dev_mean'] = a['ln_daily_return'] - a['rol_avg']\n",
    "        # next variance is calculated for certain days\n",
    "        a['dev_mean_sq'] = a['dev_mean']**2\n",
    "        a['variance'] = a['dev_mean_sq'].rolling(str(days)+'d').sum()/(a['dev_mean_sq'].rolling(str(days)+'d').count()-1)\n",
    "        # volatility is square root of variance\n",
    "        # do you need annual volatility?\n",
    "        df[name + '_daily_vol'] = np.sqrt(a['variance'])*np.sqrt(252) # 252 trading days in a year\n",
    "        #df.drop(['ln_daily_return'])#,'rol_avg','dev_mean','dev_mean_sq','variance'])\n",
    "        #return df[name + '_daily_vol']\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def stationary_timeseries(df, damned_list = ['volume','std','short','daily']):\n",
    "    # makes columns in df that are not in damned list stationary. Means it calculates the \n",
    "    # difference row by row\n",
    "    columns = df.columns\n",
    "    df_sta = pd.DataFrame()\n",
    "    for column in columns:\n",
    "        if any(elem in column for elem in damned_list):\n",
    "            df_sta[column] = df[column]\n",
    "        else:\n",
    "            df_sta[column+'_sta'] = df[column] - df[column].shift(1)\n",
    "    df_sta.dropna(inplace = True)  # to make sure we have all the data on all the days\n",
    "    return df_sta"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_df(var_name_list,name_list):\n",
    "    # takes list paths of csv files and names and passes it on to get_data.\n",
    "    # Gets df from get_data and merges them on 'Date'\n",
    "    # Calls sigma_fct to get sigma of daily returns \n",
    "    # var_name_list: list of paths to csv files\n",
    "    # name: list of names the columns of df\n",
    "    i=0\n",
    "    for var_name in var_name_list:\n",
    "        if i == 0:\n",
    "            df = get_data(var_name, name_list[i])\n",
    "        else:\n",
    "            df = pd.merge(df,get_data(var_name, name_list[i]),on='Date')\n",
    "        i += 1\n",
    "    df.dropna(inplace = True)  # to make sure we have all the data on all the days\n",
    "    \n",
    "    df = sigma_fct(df,names)\n",
    "    df=df[23:] # drop first entries to get clean results\n",
    "\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_target_data(df, name):\n",
    "    # function to create the target data\n",
    "    # name: name of the column the target data is created of\n",
    "    df[name+'_45d'] = df[name].shift(-32) # stock price in 45 days (approx. 32 trading days)\n",
    "    df.dropna(inplace = True)  # to make sure we have all the data on all the days\n",
    "    # df['short_call'] shows the perfect short call. If you would have shorted a call option with a strike price \n",
    "    # exactly the same as the stock price 45 days later, you made maximum profit. Therefore this is the target \n",
    "    # value for the short call option. The minimum is 0, so we never short a call option with a strike price\n",
    "    # below the stock price right now. The same for the short put option\n",
    "    df['short_call'] = [x/y-1 if x/y > 1 else 0 for x,y in df[[name+'_45d', name]].values]\n",
    "    df['short_put'] = [1-x/y if x/y < 1 else 0 for x,y in df[[name+'_45d', name]].values]\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "var_names = ['GOOG','S&P','Nasdaq2']\n",
    "names = ['google','s&p','nasdaq']\n",
    "df = get_df(var_names, names)\n",
    "df = get_target_data(df, 'google')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup['df'] = df"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Price of options\n",
    "It is really hard to get data about historic stock options. Be it as api channel or csv download. I managed only to find sources to pay: 500 USD for every year. Because that is too expensive for this project I decided to calculate the option price with the **Black–Scholes formula**, which gives a theoretical estimate of the price of European-style options.\n",
    "\n",
    "Based on the formula for non-divident paying options I calculate the option prices and add a small random term to create a bit of noise."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def black_scholes(S, K, sigma, r=0.03, T=45/365, option = 'call'):\n",
    "    \n",
    "    #S: spot price\n",
    "    #K: strike price\n",
    "    #T: time to maturity in years, 45 days as default\n",
    "    #r: risk-free interest rate, assumed to be constant between t and T\n",
    "    #sigma: standard deviation (volatility) of RETURNS of underlying asset\n",
    "    \n",
    "    d1 = (np.log(S / K) + (r + 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))\n",
    "    #d2 = (np.log(S / K) + (r - 0.5 * sigma ** 2) * T) / (sigma * np.sqrt(T))\n",
    "    d2 = d1 - sigma * np.sqrt(T)\n",
    "    \n",
    "    if option == 'call':\n",
    "        result = (S * si.norm.cdf(d1, 0.0, 1.0) - K * np.exp(-r * T) * si.norm.cdf(d2, 0.0, 1.0))\n",
    "    if option == 'put':\n",
    "        result = (K * np.exp(-r * T) * si.norm.cdf(-d2, 0.0, 1.0) - S * si.norm.cdf(-d1, 0.0, 1.0))\n",
    "        \n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def option_prices(date, short_spread, long_spread, strike_days = 45):\n",
    "    # calculates prices of options and calculates initial return (net premium)\n",
    "    date = date_fct(date)\n",
    "    P_s_strike_price, P_l_strike_price, C_s_strike_price, C_l_strike_price = strike_prices(date, short_spread, long_spread)\n",
    "    sigma = get_sigma(date)\n",
    "    stock_price = stock_price_fct(date)\n",
    "    P_s_price = black_scholes(stock_price, P_s_strike_price, sigma, T=strike_days/365, option = 'put')\n",
    "    P_l_price = black_scholes(stock_price, P_l_strike_price, sigma, T=strike_days/365, option = 'put')\n",
    "    C_s_price = black_scholes(stock_price, C_s_strike_price, sigma, T=strike_days/365, option = 'call')\n",
    "    C_l_price = black_scholes(stock_price, C_l_strike_price, sigma, T=strike_days/365, option = 'call')\n",
    "    initial_return = P_s_price + C_s_price - P_l_price - C_l_price\n",
    "    \n",
    "    return P_s_price, P_l_price, C_s_price, C_l_price, initial_return"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now it is time to calculate the strike prices and option prices of all 4 options and the initial return by setting up the iron condor"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculate return of options\n",
    "There are five different regimes for the return. R: return, P(C) put(call) option, s(l): short(long), ir: initial return, stock_price: stock price\n",
    "- stock price is below long put option: R = ir + P_l_strike_price - P_s_strike_price\n",
    "- stock price is between long and short put option: R = ir + stock_price - P_s_strike_price\n",
    "- stock price is between short call and short put option: R = ir\n",
    "- stock price is between short and long call option: R = ir - stock_price + C_s_strike price\n",
    "- stock price is above long call option: R = ir - C_l_strike_price + C_s_strike_price"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Define return function of iron condor"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def ic_return(trading_date, short_spread, long_spread, strike_days = 45):\n",
    "    P_s_strike_price, P_l_strike_price, C_s_strike_price, C_l_strike_price = strike_prices(trading_date, short_spread, long_spread)\n",
    "    P_s_price, P_l_price, C_s_price, C_l_price, initial_return = option_prices(trading_date,short_spread, long_spread, strike_days)\n",
    "    strike_date = date_fct(trading_date, 45)\n",
    "    final_stock_price = stock_price_fct(strike_date)\n",
    "    if final_stock_price < P_l_strike_price:\n",
    "        final_result = initial_return + P_l_strike_price - P_s_strike_price\n",
    "    elif final_stock_price >= P_l_strike_price and final_stock_price < P_s_strike_price:\n",
    "        final_result = initial_return + stock_price - P_s_strike_price\n",
    "    elif final_stock_price >= P_s_strike_price and final_stock_price < C_s_strike_price:\n",
    "        final_result = initial_return\n",
    "    elif final_stock_price >= C_s_strike_price and final_stock_price < C_l_strike_price:\n",
    "        final_result = initial_return - final_stock_price + C_s_strike_price\n",
    "    elif final_stock_price >= C_l_strike_price:\n",
    "        final_result = initial_return - C_l_strike_price + C_s_strike_price\n",
    "    maximum_result = initial_return\n",
    "    return final_result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Building the model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scale data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/matthias/anaconda3/lib/python3.7/site-packages/sklearn/preprocessing/data.py:334: DataConversionWarning: Data with input dtype int64, float64 were all converted to float64 by MinMaxScaler.\n",
      "  return self.partial_fit(X, y)\n"
     ]
    }
   ],
   "source": [
    "scaler = preprocessing.MinMaxScaler(feature_range=(-1, 1))\n",
    "df_scaled = pd.DataFrame(scaler.fit_transform(df), columns=df.columns, index = df.index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Split into train and test set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_train_test_data(data, train_test_split, batch_size):\n",
    "    # data is dataframe to get train test data out of\n",
    "    train_size_raw = data.shape[0]*train_test_split\n",
    "    train_size = int(train_size_raw - train_size_raw % batch_size) # make train_size multiple of batch_size for \"statefull = True\" in LSTM\n",
    "    train_data = data.iloc[0:train_size]\n",
    "    test_size_raw = data.shape[0] - train_size\n",
    "    test_size = int(test_size_raw - test_size_raw%batch_size) # multiple of batch_size\n",
    "    test_data = data.iloc[train_size : train_size + test_size]\n",
    "    x_train = train_data.drop(columns=['google_45d','short_call','short_put']) # google_45d is not for training, just for reversing stationarity\n",
    "    y_train = train_data[['short_call','short_put']]\n",
    "    x_test = test_data.drop(columns=['google_45d','short_call','short_put'])\n",
    "    y_test = test_data[['short_call','short_put']]\n",
    "    train_index=x_train.index\n",
    "    x_columns = x_train.columns\n",
    "    test_index = x_test.index\n",
    "    return x_train, x_test, y_train, y_test, test_data, test_index, x_columns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 10\n",
    "train_test_split = 0.9\n",
    "x_train, x_test, y_train, y_test, test_data, test_index, x_columns = get_train_test_data(df_scaled, train_test_split, batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sequential model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build the model architecture\n",
    "seq_model = Sequential()\n",
    "seq_model.add(Dense(128, activation='relu', input_shape=(x_train.shape[1],)))\n",
    "seq_model.add(Dropout(0.2))\n",
    "seq_model.add(Dense(16, activation='relu'))\n",
    "seq_model.add(Dropout(0.2))\n",
    "seq_model.add(Dense(4, activation='relu'))\n",
    "seq_model.add(Dropout(0.2))\n",
    "seq_model.add(Dense(2))\n",
    "\n",
    "# Compile the model using a loss function and an optimizer.\n",
    "seq_model.compile(optimizer='adam',loss='mean_squared_error')\n",
    "seq_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_seq = time.time()\n",
    "history=seq_model.fit(x_train, y_train, epochs=3000, batch_size=50, verbose=1, validation_data=(x_test, y_test));\n",
    "end_seq = time.time()\n",
    "time_seq = end_seq - start_seq\n",
    "time_seq"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "seq_model.evaluate(x_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib import pyplot\n",
    "pyplot.plot(history.history['loss'], label='Training Loss')\n",
    "pyplot.plot(history.history['val_loss'], label='Testing Loss')\n",
    "plt.yscale(\"log\")\n",
    "pyplot.legend()\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate predictions\n",
    "raw_seq_predictions = pd.DataFrame(seq_model.predict(x_test),columns = ['seq_call_prediction','seq_put_prediction'], index = test_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invert scaling for prediction data\n",
    "x_test = pd.DataFrame(x_test, columns = x_columns, index = test_index)\n",
    "unscaled_seq_predictions = pd.concat([x_test, test_data.google_45d], axis=1)\n",
    "unscaled_seq_predictions = pd.concat([unscaled_seq_predictions, raw_seq_predictions], axis=1)\n",
    "unscaled_seq_predictions = pd.DataFrame(scaler.inverse_transform(unscaled_seq_predictions), columns=unscaled_seq_predictions.columns, index=unscaled_seq_predictions.index)\n",
    "\n",
    "# Invert scaling for actual data\n",
    "unscaled_data = pd.concat([x_test, test_data.google_45d], axis=1)\n",
    "unscaled_data = pd.concat([unscaled_data, y_test], axis=1)\n",
    "unscaled_data = pd.DataFrame(scaler.inverse_transform(unscaled_data), columns=unscaled_data.columns, index=unscaled_data.index)\n",
    "#unscaled_data = unscaled_data['google_45d_sta']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup['unscaled_seq_predictions'] = unscaled_seq_predictions\n",
    "backup['unscaled_data'] = unscaled_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unscaled_seq_predictions.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "unscaled_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq_call_accuracy=np.sqrt(metrics.mean_squared_error(unscaled_data.short_call, unscaled_seq_predictions.seq_call_prediction))\n",
    "seq_put_accuracy=np.sqrt(metrics.mean_squared_error(unscaled_data.short_put, unscaled_seq_predictions.seq_put_prediction))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot prediction vs actual call spread\n",
    "plt.plot(unscaled_data['short_call'], label='Call spread')\n",
    "plt.plot(unscaled_seq_predictions['seq_call_prediction'], label='FF predicted call spread')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot prediction vs actual put spread\n",
    "pyplot.plot(unscaled_data['short_put'], label='Put spread')\n",
    "pyplot.plot(unscaled_seq_predictions['seq_put_prediction'], label='FF predicted put spread')\n",
    "pyplot.legend()\n",
    "pyplot.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### LSTM model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Split into train and test set\n",
    "And here you have to be careful according to https://machinelearningmastery.com/time-series-forecasting-long-short-term-memory-network-python/ :\n",
    "\n",
    "\"A benefit of this type of network is that it can learn and remember over long sequences and does not rely on a pre-specified window lagged observation as input. In Keras, this is referred to as stateful, and involves setting the “stateful” argument to “True” when defining an LSTM layer. By default, an LSTM layer in Keras maintains state between data within one batch. A batch of data is a fixed-sized number of rows from the training dataset that defines how many patterns to process before updating the weights of the network. State in the LSTM layer between batches is cleared by default, therefore we must make the LSTM stateful. This gives us fine-grained control over when state of the LSTM layer is cleared, by calling the reset_states() function.\"\n",
    "\n",
    "But in order to can use \"stateful = True\" the data has to be a multiple of the batch size. Therefore I have to use modulo to get the test size correctly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size = 10\n",
    "train_test_split = 0.9\n",
    "x_train, x_test, y_train, y_test, test_data, test_index, x_columns = get_train_test_data(df_scaled, train_test_split, batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "x_train=x_train.to_numpy()\n",
    "y_train=y_train.to_numpy()\n",
    "x_test = x_test.to_numpy()\n",
    "y_test = y_test.to_numpy()\n",
    "# Reshape data for (Sample, Timesteps, Features)\n",
    "x_train = x_train.reshape(x_train.shape[0], 1, x_train.shape[1])\n",
    "x_test = x_test.reshape(x_test.shape[0], 1, x_test.shape[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:74: The name tf.get_default_graph is deprecated. Please use tf.compat.v1.get_default_graph instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:517: The name tf.placeholder is deprecated. Please use tf.compat.v1.placeholder instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:4138: The name tf.random_uniform is deprecated. Please use tf.random.uniform instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:133: The name tf.placeholder_with_default is deprecated. Please use tf.compat.v1.placeholder_with_default instead.\n",
      "\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:3445: calling dropout (from tensorflow.python.ops.nn_ops) with keep_prob is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Please use `rate` instead of `keep_prob`. Rate should be set to `rate = 1 - keep_prob`.\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/optimizers.py:790: The name tf.train.Optimizer is deprecated. Please use tf.compat.v1.train.Optimizer instead.\n",
      "\n",
      "_________________________________________________________________\n",
      "Layer (type)                 Output Shape              Param #   \n",
      "=================================================================\n",
      "lstm_1 (LSTM)                (None, 1, 100)            56000     \n",
      "_________________________________________________________________\n",
      "lstm_2 (LSTM)                (None, 100)               80400     \n",
      "_________________________________________________________________\n",
      "dense_1 (Dense)              (None, 2)                 202       \n",
      "=================================================================\n",
      "Total params: 136,602\n",
      "Trainable params: 136,602\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "lstm_model = Sequential()\n",
    "lstm_model.add(LSTM(units=100, input_shape = (x_train.shape[1], x_train.shape[2]), dropout = 0.2, return_sequences = True))\n",
    "lstm_model.add(LSTM(units = 100, dropout = 0.2))\n",
    "lstm_model.add(Dense(2))\n",
    "lstm_model.compile(optimizer = 'adam', loss='mse')\n",
    "lstm_model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/tensorflow/python/ops/math_grad.py:1250: add_dispatch_support.<locals>.wrapper (from tensorflow.python.ops.array_ops) is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "Use tf.where in 2.0, which has the same broadcast rule as np.where\n",
      "WARNING:tensorflow:From /home/matthias/anaconda3/lib/python3.7/site-packages/keras/backend/tensorflow_backend.py:986: The name tf.assign_add is deprecated. Please use tf.compat.v1.assign_add instead.\n",
      "\n",
      "Train on 2370 samples, validate on 270 samples\n",
      "Epoch 1/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1664 - val_loss: 0.2071\n",
      "Epoch 2/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1313 - val_loss: 0.1641\n",
      "Epoch 3/100\n",
      "2370/2370 [==============================] - 2s 955us/step - loss: 0.1275 - val_loss: 0.1789\n",
      "Epoch 4/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1254 - val_loss: 0.1647\n",
      "Epoch 5/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1238 - val_loss: 0.1586\n",
      "Epoch 6/100\n",
      "2370/2370 [==============================] - 2s 830us/step - loss: 0.1239 - val_loss: 0.1513\n",
      "Epoch 7/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1229 - val_loss: 0.1623\n",
      "Epoch 8/100\n",
      "2370/2370 [==============================] - 2s 868us/step - loss: 0.1222 - val_loss: 0.1420\n",
      "Epoch 9/100\n",
      "2370/2370 [==============================] - 2s 1ms/step - loss: 0.1234 - val_loss: 0.1541\n",
      "Epoch 10/100\n",
      "2370/2370 [==============================] - 2s 656us/step - loss: 0.1213 - val_loss: 0.1465\n",
      "Epoch 11/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1221 - val_loss: 0.1457\n",
      "Epoch 12/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1214 - val_loss: 0.1605\n",
      "Epoch 13/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1204 - val_loss: 0.1763\n",
      "Epoch 14/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1202 - val_loss: 0.1812\n",
      "Epoch 15/100\n",
      "2370/2370 [==============================] - 2s 728us/step - loss: 0.1198 - val_loss: 0.1574\n",
      "Epoch 16/100\n",
      "2370/2370 [==============================] - 2s 854us/step - loss: 0.1208 - val_loss: 0.1480\n",
      "Epoch 17/100\n",
      "2370/2370 [==============================] - 2s 797us/step - loss: 0.1188 - val_loss: 0.1358\n",
      "Epoch 18/100\n",
      "2370/2370 [==============================] - 2s 867us/step - loss: 0.1198 - val_loss: 0.1537\n",
      "Epoch 19/100\n",
      "2370/2370 [==============================] - 2s 806us/step - loss: 0.1180 - val_loss: 0.1540\n",
      "Epoch 20/100\n",
      "2370/2370 [==============================] - 2s 1ms/step - loss: 0.1171 - val_loss: 0.1535\n",
      "Epoch 21/100\n",
      "2370/2370 [==============================] - 2s 672us/step - loss: 0.1180 - val_loss: 0.1430\n",
      "Epoch 22/100\n",
      "2370/2370 [==============================] - 1s 537us/step - loss: 0.1173 - val_loss: 0.1391\n",
      "Epoch 23/100\n",
      "2370/2370 [==============================] - 2s 734us/step - loss: 0.1163 - val_loss: 0.1460\n",
      "Epoch 24/100\n",
      "2370/2370 [==============================] - 2s 656us/step - loss: 0.1163 - val_loss: 0.1528\n",
      "Epoch 25/100\n",
      "2370/2370 [==============================] - 2s 990us/step - loss: 0.1172 - val_loss: 0.1531\n",
      "Epoch 26/100\n",
      "2370/2370 [==============================] - 2s 637us/step - loss: 0.1162 - val_loss: 0.1539\n",
      "Epoch 27/100\n",
      "2370/2370 [==============================] - 2s 659us/step - loss: 0.1156 - val_loss: 0.1430\n",
      "Epoch 28/100\n",
      "2370/2370 [==============================] - 2s 863us/step - loss: 0.1160 - val_loss: 0.1353\n",
      "Epoch 29/100\n",
      "2370/2370 [==============================] - 2s 670us/step - loss: 0.1146 - val_loss: 0.1481\n",
      "Epoch 30/100\n",
      "2370/2370 [==============================] - 2s 797us/step - loss: 0.1145 - val_loss: 0.1649\n",
      "Epoch 31/100\n",
      "2370/2370 [==============================] - 2s 738us/step - loss: 0.1162 - val_loss: 0.1504\n",
      "Epoch 32/100\n",
      "2370/2370 [==============================] - 2s 753us/step - loss: 0.1133 - val_loss: 0.1419\n",
      "Epoch 33/100\n",
      "2370/2370 [==============================] - 2s 899us/step - loss: 0.1141 - val_loss: 0.1537\n",
      "Epoch 34/100\n",
      "2370/2370 [==============================] - 2s 896us/step - loss: 0.1146 - val_loss: 0.1465\n",
      "Epoch 35/100\n",
      "2370/2370 [==============================] - 1s 568us/step - loss: 0.1146 - val_loss: 0.1639\n",
      "Epoch 36/100\n",
      "2370/2370 [==============================] - 1s 587us/step - loss: 0.1140 - val_loss: 0.1496\n",
      "Epoch 37/100\n",
      "2370/2370 [==============================] - 2s 941us/step - loss: 0.1133 - val_loss: 0.1460\n",
      "Epoch 38/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1132 - val_loss: 0.1493\n",
      "Epoch 39/100\n",
      "2370/2370 [==============================] - 2s 820us/step - loss: 0.1141 - val_loss: 0.1442\n",
      "Epoch 40/100\n",
      "2370/2370 [==============================] - 2s 688us/step - loss: 0.1136 - val_loss: 0.1429\n",
      "Epoch 41/100\n",
      "2370/2370 [==============================] - 1s 500us/step - loss: 0.1128 - val_loss: 0.1460\n",
      "Epoch 42/100\n",
      "2370/2370 [==============================] - 1s 448us/step - loss: 0.1125 - val_loss: 0.1591\n",
      "Epoch 43/100\n",
      "2370/2370 [==============================] - 2s 787us/step - loss: 0.1120 - val_loss: 0.1525\n",
      "Epoch 44/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1111 - val_loss: 0.1484\n",
      "Epoch 45/100\n",
      "2370/2370 [==============================] - 1s 509us/step - loss: 0.1115 - val_loss: 0.1535\n",
      "Epoch 46/100\n",
      "2370/2370 [==============================] - 1s 504us/step - loss: 0.1106 - val_loss: 0.1543\n",
      "Epoch 47/100\n",
      "2370/2370 [==============================] - 2s 1ms/step - loss: 0.1118 - val_loss: 0.1446\n",
      "Epoch 48/100\n",
      "2370/2370 [==============================] - 2s 788us/step - loss: 0.1100 - val_loss: 0.1471\n",
      "Epoch 49/100\n",
      "2370/2370 [==============================] - 1s 546us/step - loss: 0.1095 - val_loss: 0.1644\n",
      "Epoch 50/100\n",
      "2370/2370 [==============================] - 2s 735us/step - loss: 0.1102 - val_loss: 0.1464\n",
      "Epoch 51/100\n",
      "2370/2370 [==============================] - 1s 451us/step - loss: 0.1102 - val_loss: 0.1536\n",
      "Epoch 52/100\n",
      "2370/2370 [==============================] - 1s 444us/step - loss: 0.1134 - val_loss: 0.1510\n",
      "Epoch 53/100\n",
      "2370/2370 [==============================] - 1s 485us/step - loss: 0.1096 - val_loss: 0.1572\n",
      "Epoch 54/100\n",
      "2370/2370 [==============================] - 2s 801us/step - loss: 0.1106 - val_loss: 0.1536\n",
      "Epoch 55/100\n",
      "2370/2370 [==============================] - 1s 613us/step - loss: 0.1092 - val_loss: 0.1577\n",
      "Epoch 56/100\n",
      "2370/2370 [==============================] - 2s 737us/step - loss: 0.1085 - val_loss: 0.1423\n",
      "Epoch 57/100\n",
      "2370/2370 [==============================] - 1s 461us/step - loss: 0.1084 - val_loss: 0.1479\n",
      "Epoch 58/100\n",
      "2370/2370 [==============================] - 2s 734us/step - loss: 0.1091 - val_loss: 0.1463\n",
      "Epoch 59/100\n",
      "2370/2370 [==============================] - 1s 558us/step - loss: 0.1083 - val_loss: 0.1500\n",
      "Epoch 60/100\n",
      "2370/2370 [==============================] - 2s 984us/step - loss: 0.1074 - val_loss: 0.1479\n",
      "Epoch 61/100\n",
      "2370/2370 [==============================] - 1s 612us/step - loss: 0.1067 - val_loss: 0.1540\n",
      "Epoch 62/100\n",
      "2370/2370 [==============================] - 2s 952us/step - loss: 0.1077 - val_loss: 0.1518\n",
      "Epoch 63/100\n",
      "2370/2370 [==============================] - 2s 849us/step - loss: 0.1072 - val_loss: 0.1488\n",
      "Epoch 64/100\n",
      "2370/2370 [==============================] - 2s 636us/step - loss: 0.1063 - val_loss: 0.1521\n",
      "Epoch 65/100\n",
      "2370/2370 [==============================] - 2s 905us/step - loss: 0.1073 - val_loss: 0.1542\n",
      "Epoch 66/100\n",
      "2370/2370 [==============================] - 2s 657us/step - loss: 0.1068 - val_loss: 0.1478\n",
      "Epoch 67/100\n",
      "2370/2370 [==============================] - 2s 730us/step - loss: 0.1050 - val_loss: 0.1475\n",
      "Epoch 68/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1047 - val_loss: 0.1712\n",
      "Epoch 69/100\n",
      "2370/2370 [==============================] - 2s 838us/step - loss: 0.1042 - val_loss: 0.1552\n",
      "Epoch 70/100\n",
      "2370/2370 [==============================] - 2s 891us/step - loss: 0.1055 - val_loss: 0.1532\n",
      "Epoch 71/100\n",
      "2370/2370 [==============================] - 1s 590us/step - loss: 0.1051 - val_loss: 0.1495\n",
      "Epoch 72/100\n",
      "2370/2370 [==============================] - 2s 795us/step - loss: 0.1051 - val_loss: 0.1648\n",
      "Epoch 73/100\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2370/2370 [==============================] - 2s 1ms/step - loss: 0.1040 - val_loss: 0.1540\n",
      "Epoch 74/100\n",
      "2370/2370 [==============================] - 2s 877us/step - loss: 0.1041 - val_loss: 0.1538\n",
      "Epoch 75/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1053 - val_loss: 0.1530\n",
      "Epoch 76/100\n",
      "2370/2370 [==============================] - 1s 485us/step - loss: 0.1024 - val_loss: 0.1593\n",
      "Epoch 77/100\n",
      "2370/2370 [==============================] - 1s 627us/step - loss: 0.1025 - val_loss: 0.1496\n",
      "Epoch 78/100\n",
      "2370/2370 [==============================] - 2s 749us/step - loss: 0.1022 - val_loss: 0.1560\n",
      "Epoch 79/100\n",
      "2370/2370 [==============================] - 2s 680us/step - loss: 0.1030 - val_loss: 0.1524\n",
      "Epoch 80/100\n",
      "2370/2370 [==============================] - 1s 446us/step - loss: 0.1031 - val_loss: 0.1494\n",
      "Epoch 81/100\n",
      "2370/2370 [==============================] - 1s 453us/step - loss: 0.1026 - val_loss: 0.1644\n",
      "Epoch 82/100\n",
      "2370/2370 [==============================] - 2s 868us/step - loss: 0.1038 - val_loss: 0.1566\n",
      "Epoch 83/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1005 - val_loss: 0.1475\n",
      "Epoch 84/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.1024 - val_loss: 0.1520\n",
      "Epoch 85/100\n",
      "2370/2370 [==============================] - 2s 738us/step - loss: 0.1020 - val_loss: 0.1593\n",
      "Epoch 86/100\n",
      "2370/2370 [==============================] - 2s 923us/step - loss: 0.0994 - val_loss: 0.1553\n",
      "Epoch 87/100\n",
      "2370/2370 [==============================] - 2s 780us/step - loss: 0.1000 - val_loss: 0.1571\n",
      "Epoch 88/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.0991 - val_loss: 0.1631\n",
      "Epoch 89/100\n",
      "2370/2370 [==============================] - 1s 559us/step - loss: 0.1017 - val_loss: 0.1569\n",
      "Epoch 90/100\n",
      "2370/2370 [==============================] - 2s 645us/step - loss: 0.1023 - val_loss: 0.1548\n",
      "Epoch 91/100\n",
      "2370/2370 [==============================] - 1s 615us/step - loss: 0.1027 - val_loss: 0.1686\n",
      "Epoch 92/100\n",
      "2370/2370 [==============================] - 1s 625us/step - loss: 0.1003 - val_loss: 0.1681\n",
      "Epoch 93/100\n",
      "2370/2370 [==============================] - 2s 700us/step - loss: 0.1012 - val_loss: 0.1606\n",
      "Epoch 94/100\n",
      "2370/2370 [==============================] - 1s 537us/step - loss: 0.1009 - val_loss: 0.1758\n",
      "Epoch 95/100\n",
      "2370/2370 [==============================] - 2s 807us/step - loss: 0.1004 - val_loss: 0.1577\n",
      "Epoch 96/100\n",
      "2370/2370 [==============================] - 3s 1ms/step - loss: 0.0993 - val_loss: 0.1564\n",
      "Epoch 97/100\n",
      "2370/2370 [==============================] - 2s 708us/step - loss: 0.1000 - val_loss: 0.1548\n",
      "Epoch 98/100\n",
      "2370/2370 [==============================] - 1s 539us/step - loss: 0.0985 - val_loss: 0.1474\n",
      "Epoch 99/100\n",
      "2370/2370 [==============================] - 2s 703us/step - loss: 0.0985 - val_loss: 0.1596\n",
      "Epoch 100/100\n",
      "2370/2370 [==============================] - 1s 484us/step - loss: 0.0982 - val_loss: 0.1683\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "191.1406147480011"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start_lstm = time.time()\n",
    "lstm_model.reset_states()\n",
    "lstm_history=lstm_model.fit(x_train, y_train, epochs=100, batch_size=batch_size, verbose=1, validation_data=(x_test, y_test));\n",
    "end_lstm = time.time()\n",
    "time_lstm = end_lstm - start_lstm\n",
    "time_lstm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2370/2370 [==============================] - 1s 226us/step\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.08887244701456232"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lstm_model.evaluate(x_train, y_train, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib import pyplot\n",
    "plt.plot(lstm_history.history['loss'], label='Training Loss')\n",
    "plt.plot(lstm_history.history['val_loss'], label='Testing Loss')\n",
    "plt.yscale(\"log\")\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Get predictions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate predictions\n",
    "raw_lstm_predictions = pd.DataFrame(lstm_model.predict(x_test, batch_size=batch_size),columns = ['lstm_call_prediction','lstm_put_prediction'], index = test_index)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Convert data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_test = x_test.reshape(x_test.shape[0], x_test.shape[2]) # transform x_test back to 2D array\n",
    "x_test = pd.DataFrame(x_test, columns = x_columns, index = test_index)\n",
    "y_test = pd.DataFrame(y_test, columns = ['short_call','short_put'], index = test_index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Invert scaling for prediction data\n",
    "unscaled_lstm_predictions = pd.concat([x_test, test_data.google_45d], axis=1)\n",
    "unscaled_lstm_predictions = pd.concat([unscaled_lstm_predictions, raw_lstm_predictions], axis=1)\n",
    "unscaled_lstm_predictions = pd.DataFrame(scaler.inverse_transform(unscaled_lstm_predictions), columns=unscaled_lstm_predictions.columns, index=unscaled_lstm_predictions.index)\n",
    "\n",
    "# Invert scaling for actual data\n",
    "test_data_unscaled = pd.concat([x_test, test_data.google_45d], axis=1)\n",
    "test_data_unscaled = pd.concat([test_data_unscaled, y_test], axis=1)\n",
    "test_data_unscaled = pd.DataFrame(scaler.inverse_transform(test_data_unscaled), columns=test_data_unscaled.columns, index=test_data_unscaled.index)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup['unscaled_lstm_predictions'] = unscaled_lstm_predictions\n",
    "backup['test_data_unscaled'] = test_data_unscaled"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy for short call spread of FF model is 0.0436 and of LSTM model is 0.0396 \n",
      "Accuracy for short cput spread of FF model is 0.0453 and of LSTM model is 0.0474\n"
     ]
    }
   ],
   "source": [
    "lstm_call_accuracy=np.sqrt(metrics.mean_squared_error(unscaled_data.short_call, unscaled_lstm_predictions.lstm_call_prediction))\n",
    "lstm_put_accuracy=np.sqrt(metrics.mean_squared_error(unscaled_data.short_put, unscaled_lstm_predictions.lstm_put_prediction))\n",
    "print('Accuracy for short call spread of FF model is {} and of LSTM model is {} \\nAccuracy for short cput spread of FF model is {} and of LSTM model is {}'.format(round(seq_call_accuracy,4), round(lstm_call_accuracy,4), round(seq_put_accuracy,4), round(lstm_put_accuracy,4)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot prediction vs actual\n",
    "plt.plot(test_data_unscaled['short_call'], label='Call spread')\n",
    "plt.plot(unscaled_seq_predictions['seq_call_prediction'], label='FF Predicted')\n",
    "plt.plot(unscaled_lstm_predictions['lstm_call_prediction'], label='LSTM Predicted')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('USD')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot prediction vs actual\n",
    "plt.plot(test_data_unscaled['short_put'], label='Put spread')\n",
    "plt.plot(unscaled_seq_predictions['seq_put_prediction'], label='FF Predicted')\n",
    "plt.plot(unscaled_lstm_predictions['lstm_put_prediction'], label='LSTM Predicted')\n",
    "plt.xlabel('Date')\n",
    "plt.ylabel('USD')\n",
    "plt.grid()\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'time_seq' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-28-b23ad24a3f75>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'Run time for feedforward model is {} seconds \\nRun time for LSTM model is {} seconds'\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtime_seq\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mtime_lstm\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'time_seq' is not defined"
     ]
    }
   ],
   "source": [
    "print('Run time for feedforward model is {} seconds \\nRun time for LSTM model is {} seconds'.format(time_seq,time_lstm))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "backup.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}