stock_price_classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:25.602530Z",
     "start_time": "2019-05-27T05:33:25.592367Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "from pandas import DataFrame,Series\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "\n",
    "from tensorflow.keras.initializers import normal\n",
    "\n",
    "import os\n",
    "\n",
    "from statsmodels.tsa.arima_model import ARIMA\n",
    "from pandas_datareader import data as pdr\n",
    "import fix_yahoo_finance as yf\n",
    "import matplotlib.pyplot as plt \n",
    "import matplotlib.dates as dates\n",
    "import matplotlib.ticker as mticker\n",
    "\n",
    "\n",
    "import datetime\n",
    "from datetime import datetime,timedelta\n",
    "import time\n",
    "from matplotlib.dates import date2num\n",
    "from pandas.tseries.offsets import Day,MonthEnd\n",
    "from pandas.tseries.offsets import Hour\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "\n",
    "yf.pdr_override()\n",
    "\n",
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "import tensorflow.keras\n",
    "from tensorflow.keras import layers\n",
    "from tensorflow.keras.callbacks import EarlyStopping,ModelCheckpoint,ReduceLROnPlateau\n",
    "\n",
    "from mxnet import nd, autograd, gluon\n",
    "from mxnet.gluon import nn, rnn\n",
    "import mxnet as mx\n",
    "\n",
    "\n",
    "import seaborn as sns\n",
    "\n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "import math\n",
    "from numpy.fft import *\n",
    "\n",
    "import matplotlib.dates as dates\n",
    "import matplotlib.ticker as mticker\n",
    "\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "\n",
    "import xgboost as xgb\n",
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "import re "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:25.637311Z",
     "start_time": "2019-05-27T05:33:25.608065Z"
    }
   },
   "outputs": [],
   "source": [
    "def download(ticker,start,end,df): ## downloads the stock data from internet\n",
    "    try:\n",
    "        df=pdr.get_data_yahoo(ticker,start,end)\n",
    "    except ValueError:\n",
    "        pass\n",
    "    return df\n",
    "\n",
    "def to_supervised(df,n_in,n_out): ## transforms the dataframe to t-(n_in) values and adds the target in time t\n",
    "    n_vars=prices.shape[1]\n",
    "    cols, names = list(), list()\n",
    "    for i in range(n_in, 0, -1):\n",
    "        cols.append(df.shift(i))\n",
    "        names += [('var%d(t-%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "    \n",
    "    for i in range(0, n_out):\n",
    "        cols.append(df.shift(-i))\n",
    "        if i == 0:\n",
    "            names += [('var%d(t)' % (j+1)) for j in range(n_vars)]\n",
    "        else:\n",
    "            names += [('var%d(t+%d)' % (j+1, i)) for j in range(n_vars)]\n",
    "            \n",
    "    agg = pd.concat(cols, axis=1)\n",
    "    agg.columns = names\n",
    "    agg.dropna(inplace=True)\n",
    "    df=agg\n",
    "    for i in range(n_in):\n",
    "        df=df.rename (columns= {\"var1(t-{})\".format(i+1): \"Open(t-{})\".format(i+1), \n",
    "                                  \"var2(t-{})\".format(i+1):\"High(t-{})\".format(i+1), \n",
    "                                  \"var3(t-{})\".format(i+1): \"Low(t-{})\".format(i+1),\n",
    "                                  \"var4(t-{})\".format(i+1): \"Close(t-{})\".format(i+1),\n",
    "                                  \"var5(t-{})\".format(i+1): \"Volume(t-{})\".format(i+1),\n",
    "                                  #\"var4(t)\": \"Close(t)\",\n",
    "                                   })\n",
    "    if(n_out==1):\n",
    "        df=df.rename (columns= {\"var4(t)\": \"Close(t)\"})\n",
    "        df.drop(['var1(t)','var2(t)','var3(t)','var5(t)'],axis=1,inplace=True)\n",
    "    else:\n",
    "        df.drop(['var1(t)','var2(t)','var3(t)','var4(t)','var5(t)'],axis=1,inplace=True)\n",
    "        df=df.rename (columns= {\"var4(t+{})\".format(n_out-1): \"Close(t+{})\".format(n_out-1)})\n",
    "        for i in range(n_out-1):\n",
    "            if((i+1)!=n_out-1):\n",
    "                df.drop(['var1(t+{})'.format(i+1),'var2(t+{})'.format(i+1),'var3(t+{})'.format(i+1),\n",
    "                        'var4(t+{})'.format(i+1),'var5(t+{})'.format(i+1)],axis=1,inplace=True)\n",
    "            else:\n",
    "                df.drop(['var1(t+{})'.format(i+1),'var2(t+{})'.format(i+1),'var3(t+{})'.format(i+1),\n",
    "                        'var5(t+{})'.format(i+1)],axis=1,inplace=True)\n",
    "                \n",
    "    return df\n",
    "\n",
    "def transform_features(df):\n",
    "    # reshape input to be [samples, time steps, features]\n",
    "    #passing data as features\n",
    "    \n",
    "    df.drop(['GS_Close(t)'],axis=1,inplace=True) \n",
    "    df.drop(['GS_High(t-1)','GS_Low(t-1)'],axis=1,inplace=True)\n",
    "\n",
    "    \n",
    "    df=np.array(df)\n",
    "    x_train=df[:len(df)-365,:-1]\n",
    "    y_train=df[:len(df)-365,-1]\n",
    "\n",
    "    Xtest=df[len(df)-365:,:-1]\n",
    "    ytest=df[len(df)-365:,-1]\n",
    "\n",
    "    y_train=y_train.reshape(-1,1)\n",
    "    ytest=ytest.reshape(-1,1)\n",
    "\n",
    "    scaler_x = MinMaxScaler()\n",
    "    scaler_x.fit(x_train)\n",
    "    x_train=scaler_x.transform(x_train)\n",
    "    Xtest=scaler_x.transform(Xtest)\n",
    "\n",
    "    scaler_y = MinMaxScaler()\n",
    "    scaler_y.fit(y_train)\n",
    "    y_train=scaler_y.transform(y_train)\n",
    "    ytest=scaler_y.transform(ytest)\n",
    "\n",
    "\n",
    "    x_train = x_train.reshape((x_train.shape[0], 1, x_train.shape[1]))\n",
    "    Xtest = Xtest.reshape((Xtest.shape[0], 1, Xtest.shape[1]))\n",
    "    return(x_train,y_train,Xtest,ytest,scaler_x,scaler_y)\n",
    "\n",
    "def transform_timesteps(df):\n",
    "    # reshape input to be [samples, time steps, features]\n",
    "    #passing data as timesteps\n",
    "    \n",
    "    df.drop(['GS_Close(t)'],axis=1,inplace=True)\n",
    "    df.drop(['GS_High(t-1)','GS_Low(t-1)'],axis=1,inplace=True)\n",
    "\n",
    "    df=np.array(df)\n",
    "    x_train=df[:len(df)-365,:-1]\n",
    "    y_train=df[:len(df)-365,-1]\n",
    "\n",
    "    Xtest=df[len(df)-365:,:-1]\n",
    "    ytest=df[len(df)-365:,-1]\n",
    "\n",
    "    y_train=y_train.reshape(-1,1)\n",
    "    ytest=ytest.reshape(-1,1)\n",
    "\n",
    "    scaler_x = MinMaxScaler()\n",
    "    scaler_x.fit(x_train)\n",
    "    x_train=scaler_x.transform(x_train)\n",
    "    Xtest=scaler_x.transform(Xtest)\n",
    "\n",
    "    scaler_y = MinMaxScaler()\n",
    "    scaler_y.fit(y_train)\n",
    "    y_train=scaler_y.transform(y_train)\n",
    "    ytest=scaler_y.transform(ytest)\n",
    "\n",
    "\n",
    "    x_train = x_train.reshape((x_train.shape[0],x_train.shape[1],1))\n",
    "    Xtest = Xtest.reshape((Xtest.shape[0],Xtest.shape[1],1))\n",
    "    return(x_train,y_train,Xtest,ytest,scaler_x,scaler_y)\n",
    "\n",
    "def MSE(actual,prediction):## Mean squared error function\n",
    "    return np.sum((actual-prediction)**2)/len(actual)\n",
    "\n",
    "def direction_gain(for_metric,open_price,all_predictions,actual_direction):\n",
    "    gain=[]\n",
    "    for i,j,k,l in zip(all_predictions,actual_direction,for_metric,open_price):\n",
    "        if i==j:\n",
    "            gain.append(np.abs(k-l))\n",
    "        if i!=j:\n",
    "            if j==0:\n",
    "                gain.append(l-k)\n",
    "            if j==1:\n",
    "                gain.append(k-l)  \n",
    "    return gain\n",
    "            \n",
    "def get_technical_indicators(dataset):\n",
    "    # Create 7 and 21 days Moving Average\n",
    "    dataset['ma7'] = dataset['GS_Close(t-1)'].rolling(window=7).mean()\n",
    "    dataset['ma21'] = dataset['GS_Close(t-1)'].rolling(window=21).mean()\n",
    "    \n",
    "    # Create MACD\n",
    "    dataset['26ema'] = dataset['GS_Close(t-1)'].ewm(span=26).mean()\n",
    "    dataset['12ema'] = dataset['GS_Close(t-1)'].ewm(span=12).mean()\n",
    "    dataset['MACD'] = (dataset['12ema']-dataset['26ema'])\n",
    "\n",
    "    # Create Bollinger Bands\n",
    "    dataset['20sd'] = dataset['GS_Close(t-1)'].rolling(20).std()\n",
    "    dataset['upper_band'] = dataset['ma21'] + (dataset['20sd']*2)\n",
    "    dataset['lower_band'] = dataset['ma21'] - (dataset['20sd']*2)\n",
    "    \n",
    "    # Create Exponential moving average\n",
    "    dataset['ema'] = dataset['GS_Close(t-1)'].ewm(com=0.5).mean()\n",
    "    \n",
    "    # Create Momentum\n",
    "    dataset['momentum'] = dataset['GS_Close(t-1)']-1\n",
    "    \n",
    "    \n",
    "    return dataset\n",
    "\n",
    "def filter_signal10(signal, threshold=1e3):\n",
    "    fourier = rfft(signal)\n",
    "    frequencies = rfftfreq(signal.size, d=10e-3/signal.size)  #change the number to change the plot\n",
    "    fourier[frequencies > threshold] = 0\n",
    "    return irfft(fourier)\n",
    "\n",
    "def filter_signal20(signal, threshold=1e3):\n",
    "    fourier = rfft(signal)\n",
    "    frequencies = rfftfreq(signal.size, d=30e-3/signal.size)  #change the number to change the plot\n",
    "    fourier[frequencies > threshold] = 0\n",
    "    return irfft(fourier)\n",
    "\n",
    "def filter_signal30(signal, threshold=1e3):\n",
    "    fourier = rfft(signal)\n",
    "    frequencies = rfftfreq(signal.size, d=20e-3/signal.size)  #change the number to change the plot\n",
    "    fourier[frequencies > threshold] = 0\n",
    "    return irfft(fourier)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:25.782413Z",
     "start_time": "2019-05-27T05:33:25.640257Z"
    }
   },
   "outputs": [],
   "source": [
    "prices=pd.read_csv(\"all_stocks/GS.csv\")\n",
    "n_in=1\n",
    "n_out=1\n",
    "prices.drop(['Date'],axis=1,inplace=True)\n",
    "prices=to_supervised(prices,n_in,n_out)\n",
    "names=[]\n",
    "for i in prices.columns:\n",
    "    names.append('GS_{}'.format(i))\n",
    "prices.columns=names\n",
    "prices.head()\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/^IXIC.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"^IXIC_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/^VIX.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"^VIX_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/BAC.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"BAC_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/BCS.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"BCS_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/CS.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"CS_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/JPM.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"JPM_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/MS.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"MS_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/HSI.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"HSI_Close\"} )\n",
    "\n",
    "prices=prices.join(extra)\n",
    "prices['HSI_Close']=prices['HSI_Close'].shift(9)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/NYA.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"NYA_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "prices['NYA_Close']=prices['NYA_Close'].shift(149)\n",
    "\n",
    "extra=pd.read_csv(\"all_stocks/^N225.csv\")\n",
    "extra.drop(['Date','Open','Low','High','Volume'],axis=1,inplace=True)\n",
    "extra=extra.rename (columns= {\"Close\":\"^N225_Close\"} )\n",
    "prices=prices.join(extra)\n",
    "prices['^N225_Close']=prices['^N225_Close'].shift(25)\n",
    "\n",
    "prices=get_technical_indicators(prices)\n",
    "\n",
    "fourier=filter_signal10(prices['GS_Close(t-1)'])\n",
    "fourier=pd.DataFrame(fourier)\n",
    "fourier=fourier.rename(columns={0:'fourier10'})\n",
    "prices=prices.join(fourier)\n",
    "prices['fourier10']=prices['fourier10'].shift(2)\n",
    "\n",
    "fourier=filter_signal20(prices['GS_Close(t-1)'])\n",
    "fourier=pd.DataFrame(fourier)\n",
    "fourier=fourier.rename(columns={0:'fourier20'})\n",
    "prices=prices.join(fourier)\n",
    "prices['fourier20']=prices['fourier20'].shift(2)\n",
    "\n",
    "fourier=filter_signal30(prices['GS_Close(t-1)'])\n",
    "fourier=pd.DataFrame(fourier)\n",
    "fourier=fourier.rename(columns={0:'fourier30'})\n",
    "prices=prices.join(fourier)\n",
    "prices['fourier30']=prices['fourier30'].shift(2)\n",
    "\n",
    "prices=prices.shift(-149).dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:25.977834Z",
     "start_time": "2019-05-27T05:33:25.784765Z"
    }
   },
   "outputs": [],
   "source": [
    "for_metric=prices['GS_Close(t)']\n",
    "for_metric.drop(1,inplace=True)\n",
    "starting=prices['GS_Open(t-1)'].shift(-1).dropna()\n",
    "prices['direction']=1.0\n",
    "prices['direction'][prices['GS_Close(t-1)']>prices['GS_Close(t)']]=0.0\n",
    "direction=prices['direction']\n",
    "prices.drop(['direction'],axis=1,inplace=True)\n",
    "prices=prices.pct_change()\n",
    "prices['direction']=direction\n",
    "prices[prices>0]=1\n",
    "prices[prices<0]=0\n",
    "prices=prices.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:26.784578Z",
     "start_time": "2019-05-27T05:33:25.980111Z"
    }
   },
   "outputs": [],
   "source": [
    "Xtrain_f,ytrain_f,Xtest_f,ytest_f,scaler_x_f,scaler_y_f=transform_timesteps(prices)\n",
    "\n",
    "model_lstm = tensorflow.keras.models.Sequential()\n",
    "model_lstm.add(layers.LSTM(80, input_shape=(Xtrain_f.shape[1], Xtrain_f.shape[2]),return_sequences=True))\n",
    "model_lstm.add(layers.LSTM(50, input_shape=(Xtrain_f.shape[1], Xtrain_f.shape[2]),activation='tanh'))\n",
    "model_lstm.add(layers.Dense(1,activation='sigmoid'))\n",
    "opt=tensorflow.keras.optimizers.Adam(lr=0.01,epsilon=None,decay=0)\n",
    "model_lstm.compile(loss='binary_crossentropy', optimizer=opt)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:27.526900Z",
     "start_time": "2019-05-27T05:33:26.786957Z"
    }
   },
   "outputs": [],
   "source": [
    "model_lstm.load_weights('classification_lstm_2.hdf5')\n",
    "trainPredict_f=model_lstm.predict(Xtrain_f)\n",
    "testPredict_f= model_lstm.predict(Xtest_f)\n",
    "\n",
    "all_predictions_f=[]\n",
    "trainPredict_f=scaler_y_f.inverse_transform(trainPredict_f)\n",
    "testPredict_f=scaler_y_f.inverse_transform(testPredict_f)\n",
    "all_predictions_f=np.append(trainPredict_f,testPredict_f)\n",
    "all_predictions_f[all_predictions_f>0.5]=1\n",
    "all_predictions_f[all_predictions_f<0.5]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:27.541674Z",
     "start_time": "2019-05-27T05:33:27.530020Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Gain for train and test : 1669.4200519999997\n",
      "Gain for test only: 818.1800089999999\n"
     ]
    }
   ],
   "source": [
    "gainz=direction_gain(for_metric,starting,all_predictions_f,direction)\n",
    "print(\"Gain for train and test :\",np.sum(gainz))\n",
    "print(\"Gain for test only:\",np.sum(gainz[544:]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:27.555191Z",
     "start_time": "2019-05-27T05:33:27.544887Z"
    }
   },
   "outputs": [],
   "source": [
    "for_plotting=pd.DataFrame(for_metric)\n",
    "for_plotting['prediction']=all_predictions_f\n",
    "for_plotting['direction']=prices['direction']\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:29.080797Z",
     "start_time": "2019-05-27T05:33:27.558311Z"
    }
   },
   "outputs": [],
   "source": [
    "pos_plot=for_plotting['GS_Close(t)'][for_plotting['direction']==for_plotting['prediction']]\n",
    "pos_plot=pos_plot.T\n",
    "for i in range(1000):\n",
    "    if i not in pos_plot.index:\n",
    "        pos_plot[i]=np.nan\n",
    "        \n",
    "pos_plot=pos_plot.sort_index()\n",
    "\n",
    "neg_plot=for_plotting['GS_Close(t)'][for_plotting['direction']!=for_plotting['prediction']]\n",
    "neg_plot=neg_plot.T\n",
    "for i in range(1000):\n",
    "    if i not in neg_plot.index:\n",
    "        neg_plot[i]=np.nan\n",
    "        \n",
    "neg_plot=neg_plot.sort_index()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:33:30.479746Z",
     "start_time": "2019-05-27T05:33:29.083316Z"
    },
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.lines.Line2D at 0x1c42a56e10>"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 2160x1440 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(30,20))\n",
    "plt.plot(for_plotting['GS_Close(t)'],'r')\n",
    "plt.plot(pos_plot,'g')\n",
    "plt.axvline(x=544,color='k')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:37:05.498371Z",
     "start_time": "2019-05-27T05:37:05.486812Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0    0.736986\n",
       "dtype: float64"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#accuracy of the days that we predicted right\n",
    "gain_acc = pd.DataFrame(gainz[544:])\n",
    "right_days = gain_acc[gain_acc>0].count()\n",
    "accuracy = right_days/len(gain_acc)\n",
    "accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2019-05-27T05:50:53.251195Z",
     "start_time": "2019-05-27T05:50:53.246630Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "38.020004"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#the gain of the stock at the time of testing\n",
    "np.abs(starting[544]-starting[909])"
   ]
  },
  {
   "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.6.5"
  },
  "latex_envs": {
   "LaTeX_envs_menu_present": true,
   "autoclose": false,
   "autocomplete": true,
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 1,
   "hotkeys": {
    "equation": "Ctrl-E",
    "itemize": "Ctrl-I"
   },
   "labels_anchors": false,
   "latex_user_defs": false,
   "report_style_numbering": false,
   "user_envs_cfg": false
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}