Neural Nets.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv(\"data-training.csv\")\n",
    "\n",
    "#impute missing values\n",
    "\n",
    "#fill missing volumes with 0\n",
    "df.iloc[:,15:30] = df.iloc[:,15:30].fillna(0)\n",
    "\n",
    "#fill missing askRates with +0.5 of the prior\n",
    "for i in range(1,15):\n",
    "    df.loc[df['askRate'+str(i)].isna(),'askRate'+str(i)] = df.loc[df['askRate'+str(i)].isna(),'askRate'+str(i-1)] + 0.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['price']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "depth = 6\n",
    "featuresIndexes = list(range(44+depth,44,-1)) + list(range(15,15+depth))+[61]\n",
    "X=((df.iloc[:,featuresIndexes] - df.iloc[:,featuresIndexes].mean())/df.iloc[:,featuresIndexes].std()).values\n",
    "y = df['y'].values.reshape(-1,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "[dict(df.iloc[:,featuresIndexes].mean())[x] for x in dict(df.iloc[:,featuresIndexes].mean())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "[dict(df.iloc[:,featuresIndexes].std())[x] for x in dict(df.iloc[:,featuresIndexes].std())]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26.86899517770618"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['price'].std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "timestep = 1\n",
    "X2 = np.zeros((X.shape[0]-timestep+1,timestep,X.shape[1]))\n",
    "\n",
    "for i in range(timestep,X.shape[0]):\n",
    "    X2[i-timestep] = X[i-timestep:i]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = []\n",
    "b = []\n",
    "for i in range(10):\n",
    "    a += [df2['askSize'+str(i)].max()]\n",
    "    b += [df2['bidSize'+str(i)].max()]\n",
    "    df2.loc[:,'askSize'+str(i)] /= df2['askSize'+str(i)].max()\n",
    "    df2.loc[:,'bidSize'+str(i)] /= df2['bidSize'+str(i)].max()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "from tensorflow.keras import optimizers\n",
    "\n",
    "def coeff_determination(y_true, y_pred):\n",
    "    \n",
    "    SS_res =  K.sum(K.square( y_true-y_pred ))\n",
    "    SS_tot = K.sum(K.square(y_true) )\n",
    "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
    "\n",
    "\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import GRU, LSTM,Dense,Flatten, Conv1D,MaxPooling1D,AveragePooling1D, Dropout\n",
    "\n",
    "model = Sequential([\n",
    "#     GRU(units=20,activation='relu',input_shape=(timestep,16)),\n",
    "#     Dropout(0.25),\n",
    "#     Dense(units=10,activation='relu'),\n",
    "    Dense(12,activation='relu',input_shape=(12,)),\n",
    "    Dense(12,activation='relu'),\n",
    "    Dense(12,activation='relu'),\n",
    "    Dense(12,activation='relu'),\n",
    "    Dense(12,activation='relu'),\n",
    "    Dense(1,activation='linear')\n",
    "])\n",
    "\n",
    "rmsProp = optimizers.RMSprop(lr=0.001, rho=0.9, epsilon=None, decay=0.0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "#from sklearn\n",
    "\n",
    "# for train_index, test_index in TimeSeriesSplit(n_splits=3).split(X2):\n",
    "#     X_train, X_test = X2[train_index], X2[test_index]\n",
    "#     y_train, y_test = y[train_index], y[test_index]\n",
    "#     model.compile(optimizer=rmsProp,loss='mse',metrics=[coeff_determination])\n",
    "#     model.fit(X_train,y_train, epochs=10, batch_size=256)\n",
    "#     model.evaluate(X_test,y_test)\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test,y_train, y_test = train_test_split(X,y,test_size=0.5)\n",
    "\n",
    "model.compile(optimizer=rmsProp,loss='mse',metrics=[coeff_determination])\n",
    "history = model.fit(X_train,y_train, epochs=10, batch_size=256, validation_data =(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-0.021865260929091173"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df['price'].diff(1).corr(df['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "coeff_determination(y_test,model.predict(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train,epochs=9,batch_size=256, validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.metrics import r2_score\n",
    "preds = model.predict(X_test)\n",
    "r2_score(y_test,preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "PCA(n)\n",
    "X = PCA.fit_transform(df.iloc[:,list(range(15,30))].values)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(15):\n",
    "    df['orderImbalance'+str(i)] = (df['askSize'+str(i)]-df['bidSize'+str(i)]) /(df['askSize'+str(i)]+df['bidSize'+str(i)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#predict directional change, magnitude seperately\n",
    "df['increased'] = (df['y'] > 0) * 1\n",
    "df['decreased'] = (df['y'] < 0) * 1\n",
    "df['magnitude'] = df['y'].abs()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2 = df[['increased', 'decreased',\n",
    "          'askSize0','askSize1','askSize2','askSize3',\n",
    "          'bidSize0','bidSize1','bidSize2','bidSize3',\n",
    "          'orderImbalance0', 'orderImbalance1','orderImbalance2', 'orderImbalance3']].drop_duplicates()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['askRate0'].diff(10).corr(df['decreased'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "means = {}\n",
    "stds = {}\n",
    "\n",
    "\n",
    "\n",
    "for i in range(4):\n",
    "    means['askSize'+str(i)] = df2['askSize'+str(i)].mean()\n",
    "    stds['askSize'+str(i)] = df2['askSize'+str(i)].std()\n",
    "    means['bidSize'+str(i)] = df2['bidSize'+str(i)].mean()\n",
    "    stds['bidSize'+str(i)] = df2['bidSize'+str(i)].std()\n",
    "    \n",
    "    df2.loc[:,'askSize'+str(i)] = (df2['askSize'+str(i)] - means['askSize'+str(i)]) / stds['askSize'+str(i)]\n",
    "    df2.loc[:,'bidSize'+str(i)] = (df2['bidSize'+str(i)] - means['bidSize'+str(i)]) / stds['bidSize'+str(i)]\n",
    "\n",
    "y = df2[['increased','decreased']].values.reshape(-1,2)\n",
    "X = df2.drop(['increased','decreased'],axis=1)\n",
    "X = X.values.reshape(-1,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "\n",
    "# def coeff_determination(y_true, y_pred):\n",
    "    \n",
    "#     SS_res =  K.sum(K.square( y_true-y_pred ))\n",
    "#     SS_tot = K.sum(K.square(y_true) )\n",
    "#     return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
    "\n",
    "\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import GRU, LSTM,Dense\n",
    "\n",
    "classifier = Sequential([\n",
    "    Dense(units=10,activation='relu', input_shape=(12,)),\n",
    "    Dense(units=10,activation='relu', input_shape=(12,)),\n",
    "    Dense(2,activation='sigmoid')\n",
    "])\n",
    "classifier.compile(optimizer=\"RMSProp\",loss='mse',metrics=['binary_crossentropy'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test,y_train, y_test = train_test_split(X,y,test_size=0.4)\n",
    "\n",
    "classifier.fit(X_train,y_train,epochs=10,batch_size=256,validation_split=0.2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "volumeIndices = list(range(15,30)) + list(range(45,60))\n",
    "df.iloc[:,volumeIndices].corrwith(df['y']).abs().sort_values(ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(15):\n",
    "    df.iloc[:,15+i] = df.iloc[:,15+i] ** (1 /    df.iloc[:,15+i].mean())\n",
    "    df.iloc[:,45+i] = df.iloc[:,30+i] ** (1 /    df.iloc[:,30+i].mean())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "volumeIndices = list(range(15,30)) + list(range(45,60))\n",
    "df.iloc[:,volumeIndices].corrwith(df['y']).abs().sort_values(ascending=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['askSize10'].hist(bins=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "volumeIndices = list(range(15,22)) + list(range(45,52))\n",
    "\n",
    "\n",
    "X = df.iloc[:,volumeIndices].values.reshape(-1,1,len(volumeIndices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, df['y'].values.reshape(-1,1),test_size=0.4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train, epochs=10, batch_size=256, validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.iloc[:,15].corr(df['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.log(1+df['bidSize2']).corr(df['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#trade becomes more likely if asks decrease, bids increase\n",
    "df['askRateDown'] = (df['askRate0'].diff(1) < 0) * 1\n",
    "df['bidRateUp'] = (df['bidRate0'].diff(1) > 0) * 1\n",
    "\n",
    "df['hit'] = (df['askRate0'] <= (df['bidRate0'] - df['bidRate0'].diff(1))) * 1\n",
    "df['lift'] = (df['bidRate0'] >= (df['askRate0'] - df['askRate0'].diff(1))) * 1\n",
    "df['price'] = (df['askRate0'] + df['bidRate0']) / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(df['askSize0']*404).describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['priceDown'] = (df['price'].diff(1) < 0) * 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['priceUp'] = (df['price'].diff(1) > 0) * 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['bidRateUp'].corr(df['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "df['bidRateUp'].rolling(10).sum().corr(df['y'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "\n",
    "\n",
    "pca = PCA(whiten=True)\n",
    "\n",
    "volumeIndices = list(range(45,55)) + list(range(15,25))\n",
    "X = pca.fit_transform(df.iloc[:,volumeIndices])\n",
    "\n",
    "from sklearn.externals import joblib\n",
    "joblib.dump(pca,\"pca.joblib\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "maxVolumes = {}\n",
    "\n",
    "for i in range(15):\n",
    "    maxVolumes['askSize'+str(i)] = df.iloc[:,15+i].max()\n",
    "    maxVolumes['bidSize'+str(i)] = df.iloc[:,45+i].max()\n",
    "    df['askSize'+str(i)] /= maxVolumes['askSize'+str(i)]\n",
    "    df['bidSize'+str(i)] /= maxVolumes['bidSize'+str(i)]\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['priceDiff10'] = df['price'].diff(10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "midPrice = ((df['askRate0']+df['bidRate0']) / 2).mean()\n",
    "\n",
    "for i in range(15):\n",
    "    df['bidRate'+str(i)] -= 1642.0\n",
    "    df['askRate'+str(i)] -= 1642.0\n",
    "    \n",
    "    \n",
    "maxPipDeviation = max(df.iloc[:,0:11].abs().values.max(),df.iloc[:,30:41].abs().values.max())\n",
    "for i in range(15):\n",
    "    \n",
    "    df['askRate'+str(i)] /= 75.0\n",
    "    df['bidRate'+str(i)] /= 75.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['askRate0Diff'] = df['askRate0'].diff(1)\n",
    "df['bidRate0Diff'] = df['bidRate0'].diff(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "maxPipDeviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#list(range(40,29,-1))+list(range(0,11))+list(range(55,44,-1))+list(range(15,26))\n",
    "featureIndexes = list(range(55,44,-1)) + list(range(15,26))\n",
    "X = df.iloc[:,featureIndexes].values.reshape((-1,22))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "\n",
    "timestep = 2\n",
    "X2 = np.zeros((X.shape[0],timestep,len(featureIndexes)))\n",
    "\n",
    "for i in range(timestep,len(X)):\n",
    "    X2[i] = X[i-timestep:i]\n",
    "\n",
    "labels = df.loc[:,'y'].values.reshape(-1,)\n",
    "\n",
    "X3 = (X2[:,1,:]- X2[:,0,:])\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X3,labels,train_size=0.6)\n",
    "#X_train, X_test, y_train, y_test = train_test_split(X2,labels,train_size=0.6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "\n",
    "def coeff_determination(y_true, y_pred):\n",
    "    \n",
    "    SS_res =  K.sum(K.square( y_true-y_pred ))\n",
    "    SS_tot = K.sum(K.square(y_true) )\n",
    "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
    "\n",
    "\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense,Flatten, Conv1D, MaxPooling1D,AveragePooling1D\n",
    "model = Sequential([   \n",
    "#Conv1D(filters=20,kernel_size=2,activation='relu',input_shape=(X_train.shape[1],X_train.shape[2])),\n",
    "#AveragePooling1D(pool_size=2,padding=\"same\"),    \n",
    "Flatten(),\n",
    "# Dropout(0.3),\n",
    "Dense(20,activation='relu',input_shape=(22,)),\n",
    "#Dropout(0.5),\n",
    "# Dense(32,activation='relu'),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Adam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X_train, y_train, batch_size=256, validation_split=0.2,epochs=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "\n",
    "def coeff_determination(y_true, y_pred):\n",
    "    \n",
    "    SS_res =  K.sum(K.square( y_true-y_pred ))\n",
    "    SS_tot = K.sum(K.square(y_true) )\n",
    "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
    "\n",
    "\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense,Flatten, Conv1D, MaxPooling1D,AveragePooling1D\n",
    "\n",
    "model = Sequential([   \n",
    "#Conv1D(filters=20,kernel_size=2,activation='relu',input_shape=(X_train.shape[1],X_train.shape[2])),\n",
    "#AveragePooling1D(pool_size=2,padding=\"same\"),    \n",
    "Flatten(),\n",
    "# Dropout(0.3),\n",
    "Dense(16,activation='relu'),\n",
    "#Dropout(0.5),\n",
    "# Dense(32,activation='relu'),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Adam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train,batch_size=512,epochs=10,validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras import backend as K\n",
    "import tensorflow as tf\n",
    "\n",
    "def coeff_determination(y_true, y_pred):\n",
    "    \n",
    "    SS_res =  K.sum(K.square( y_true-y_pred ))\n",
    "    SS_tot = K.sum(K.square(y_true) )\n",
    "    return ( 1 - SS_res/(SS_tot + K.epsilon()) )\n",
    "\n",
    "\n",
    "\n",
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense,Flatten, Conv2D\n",
    "\n",
    "model = Sequential([   \n",
    "Conv2D(filters=21,kernel_size=2,activation='relu',input_shape=(X_train.shape[1],X_train.shape[2],X_train.shape[3])),\n",
    "#AveragePooling1D(pool_size=2,padding=\"same\"),    \n",
    "Flatten(),\n",
    "# Dropout(0.3),\n",
    "Dense(10,activation='relu'),\n",
    "#Dropout(0.5),\n",
    "# Dense(32,activation='relu'),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Adam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train,batch_size=512,epochs=10,validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train,batch_size=256,epochs=10,validation_split=0.2)\n",
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.loc[(df['askSize0'].diff(1) != 0) | df['bidSize0'].diff(1) != 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.layers[0].weights[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense,Conv1D,Flatten,AveragePooling1D\n",
    "\n",
    "model = Sequential([\n",
    "Conv1D(16,kernel_size=2, activation='relu',input_shape=(2,6)),\n",
    "AveragePooling1D(pool_size=2,padding=\"same\"),\n",
    "Flatten(),\n",
    "Dense(8,activation='relu'),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Nadam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "features[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(2,len(features)):\n",
    "    data.append(features[i-2:i].reshape(2,6))\n",
    "    targets.append(labels[i-2:i].reshape(2,1))\n",
    "data = np.array(data)\n",
    "labels = np.array(labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import Dense,Conv1D,Flatten,AveragePooling1D\n",
    "\n",
    "model = Sequential([\n",
    "Conv1D(16,kernel_size=2, activation='relu',input_shape=(2,6)),\n",
    "AveragePooling1D(pool_size=2,padding=\"same\"),\n",
    "Flatten(),\n",
    "Dense(8,activation='relu'),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Nadam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "history = model.fit(np.array(X_train),np.array(y_train),epochs=10,batch_size=1024,validation_split=0.2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(np.array(X_test),np.array(y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(history.history['loss'])\n",
    "plt.plot(history.history['val_loss'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(history.history['coeff_determination'])\n",
    "plt.plot(history.history['val_coeff_determination'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "preds = model.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(y_test-preds)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lstm.fit(X_train,y_train, epochs=10,batch_size=1024,validation_data=(X_test,y_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Prices = df[['askRate0','bidRate0']].copy()\n",
    "\n",
    "\n",
    "y = df['y'].values.reshape(-1,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "Prices.loc[:,'askRate0'] -= 1642.0\n",
    "Prices.loc[:,'bidRate0'] -= 1642.0\n",
    "Prices.loc[:,'askRate0'] /= 25.0\n",
    "Prices.loc[:,'bidRate0'] /= 25.0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "Prices.describe()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "indices = list(range(15,25)) + list(range(45,55)) + [0] + [30]\n",
    "X = df.iloc[:,indices].values.reshape(-1,len(indices))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.model_selection import train_test_split\n",
    "\n",
    "X_train, X_test, y_train, y_test = train_test_split(X.reshape(-1,1,22),y,test_size=0.4, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from tensorflow.keras.models import Sequential\n",
    "from tensorflow.keras.layers import GRU,Dense\n",
    "\n",
    "model = Sequential([\n",
    "GRU(10,activation='relu',input_shape=(1,22)),\n",
    "Dense(1)])\n",
    "model.compile(optimizer=\"Adam\",loss='mse',metrics=[coeff_determination])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(X_train,y_train,batch_size=256,epochs=9,validation_split=(0.2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.evaluate(X_test,y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"model.h5\")"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}