Module 4 - Algo Trading using Classification.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Module 4 - Algo Trading using Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------#"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Query 4.1\n",
    "Import the csv file of the stock which contained the Bollinger columns as well. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Importing some basic libraries\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from matplotlib import pyplot as plt\n",
    "import scikitplot\n",
    "from sklearn.model_selection import train_test_split, cross_val_score, ShuffleSplit, GridSearchCV\n",
    "from sklearn.metrics import classification_report, accuracy_score, r2_score, make_scorer\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')\n",
    "%matplotlib inline\n",
    "plt.style.use(\"grayscale\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Stock file of GMR Infrastructure Ltd (NSE: GMRINFRA) containing Bollinger Bands\n",
    "df = pd.read_csv(\"Datasets/week3.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.1.1\n",
    "\n",
    "Create a new column 'Call' , whose entries are: \n",
    "1. 'Buy' if the stock price is below the lower Bollinger band\n",
    "2. 'Hold Buy/ Liquidate Short' if the stock price is between the lower and middle Bollinger band\n",
    "3. 'Hold Short/ Liquidate Buy' if the stock price is between the middle and upper Bollinger band\n",
    "4. 'Short' if the stock price is above the upper Bollinger band "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Creating New Column \n",
    "df['Call'] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in range(df.shape[0]):\n",
    "    if df['Lower Band'][x] == 0:\n",
    "        continue\n",
    "    elif df['Close Price'][x] < df['Lower Band'][x]:\n",
    "        df['Call'][x] = 'Buy'\n",
    "    elif df['Close Price'][x] >= df['Lower Band'][x] and df['Close Price'][x] < df['Middle Band'][x]:\n",
    "        df['Call'][x] = 'Hold Buy/ Liquidate Short'\n",
    "    elif df['Close Price'][x] < df['Upper Band'][x] and df['Close Price'][x] >= df['Middle Band'][x]:\n",
    "        df['Call'][x] = 'Hold Short/ Liquidate Buy'\n",
    "    elif df['Close Price'][x] > df['Upper Band'][x]:\n",
    "        df['Call'][x] = 'Short'\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(inplace=True)\n",
    "df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.1.2\n",
    "Now train a classification model with the 3 bollinger columns and the stock price as inputs and 'Calls' as output. Check the accuracy on a test set. (There are many classifier models to choose from, try each one out and compare the accuracy for each)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Changing String value of Call to integer\n",
    "unq = df['Call'].unique()\n",
    "k = 0\n",
    "call_dict = {}\n",
    "for y in unq:\n",
    "    call_dict[y] = k\n",
    "    k+=1\n",
    "df['Call'] = df['Call'].map(call_dict).astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Splitting & Pre-processing of Data\n",
    "X_train, X_test, y_train, y_test = train_test_split(df[['Close Price','Lower Band','Middle Band','Upper Band']], df['Call'], test_size=0.3, random_state=42)\n",
    "\n",
    "sc = StandardScaler()\n",
    "X_train = sc.fit_transform(X_train)\n",
    "X_test = sc.transform(X_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### K Nearest Neighbors Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.9103448275862069\n"
     ]
    }
   ],
   "source": [
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "\n",
    "classifier = KNeighborsClassifier(n_neighbors=5, algorithm='auto')\n",
    "classifier.fit(X_train,y_train)\n",
    "\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Logistic Regression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.8896551724137931\n"
     ]
    }
   ],
   "source": [
    "# Fitting Logistic Regression to the Training set\n",
    "from sklearn.linear_model import LogisticRegression\n",
    "classifier = LogisticRegression(random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Support Vector Machine - Linear"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.9241379310344827\n"
     ]
    }
   ],
   "source": [
    "from sklearn.svm import SVC\n",
    "classifier = SVC(kernel = 'linear', random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Support Vector Machine - Radial basis function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.9103448275862069\n"
     ]
    }
   ],
   "source": [
    "#from sklearn.svm import SVC\n",
    "classifier = SVC(kernel = 'rbf', random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Navie Bayes - Gaussian"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.6\n"
     ]
    }
   ],
   "source": [
    "from sklearn.naive_bayes import GaussianNB\n",
    "classifier = GaussianNB()\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Navie Bayes - Bernoulli"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.6068965517241379\n"
     ]
    }
   ],
   "source": [
    "from sklearn.naive_bayes import BernoulliNB\n",
    "classifier = BernoulliNB()\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))\n",
    "# You can not apply ComplementNB and MultinomialNB on negative Data\n",
    "# We are getting low accuracy on NB because NB is suitable for Text Classification"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Decision Tree Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.8275862068965517\n"
     ]
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "classifier = DecisionTreeClassifier(criterion = 'entropy', random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Random Forest Classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Accuracy is 0.8689655172413793\n"
     ]
    }
   ],
   "source": [
    "from sklearn.ensemble import RandomForestClassifier\n",
    "classifier = RandomForestClassifier(n_estimators = 200, criterion = 'entropy', random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)\n",
    "\n",
    "print(\"Accuracy is {}\".format(accuracy_score(y_test, y_pred, normalize=True)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### SVM - Linear has given best accuracy out of all the models"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.1.3\n",
    "\n",
    "Import another stock data and create the bollinger columns. Using the already defined model, predict the daily calls for this new stock."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# As SVM - Linear has given best accuracy. So, We are using SVM - Linear for further classification.\n",
    "#Importing New Stock file - IDBI Bank LTD.\n",
    "df2 = pd.read_csv(\"Datasets/MID_CAP/IDBI.csv\")\n",
    "#Adding Bollinger Bands in IDBI\n",
    "X14 = df2['Close Price'].rolling(14,min_periods=14).mean()\n",
    "X141 = 2*(df2['Close Price'].rolling(14,min_periods=14).std())\n",
    "X142 = X14 - X141\n",
    "X143 = X14 + X141 \n",
    "df2['Lower Band'] = X142\n",
    "df2['Middle Band'] = X14\n",
    "df2['Upper Band'] = X143"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array(['EQ'], dtype=object)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Checking For Equity Values\n",
    "df2['Series'].unique()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Dropping NaN's \n",
    "df2.dropna(inplace=True)\n",
    "df2.reset_index(drop=True, inplace=True)\n",
    "df2['Call'] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Training & Pre-processing\n",
    "X_train = sc.fit_transform(df[['Close Price','Lower Band','Middle Band','Upper Band']])\n",
    "X_test = sc.transform(df2[['Close Price','Lower Band','Middle Band','Upper Band']])\n",
    "y_train = df['Call']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier = SVC(kernel = 'linear', random_state = 0)\n",
    "classifier.fit(X_train, y_train)\n",
    "\n",
    "# Predicting the Test set results\n",
    "y_pred = classifier.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "df2['Call'] = y_pred\n",
    "#Invert Mapping\n",
    "inv_map = {v: k for k, v in call_dict.items()}\n",
    "df2 = df2.replace({\"Call\": inv_map})\n",
    "df2['Actual_Call'] = np.nan\n",
    "#Creating Column with Actual Call Value\n",
    "for x in range(df2.shape[0]):\n",
    "    if df2['Lower Band'][x] == 0:\n",
    "        continue\n",
    "    elif df2['Close Price'][x] < df2['Lower Band'][x]:\n",
    "        df2['Actual_Call'][x] = 'Buy'\n",
    "    elif df2['Close Price'][x] >= df2['Lower Band'][x] and df2['Close Price'][x] < df2['Middle Band'][x]:\n",
    "        df2['Actual_Call'][x] = 'Hold Buy/ Liquidate Short'\n",
    "    elif df2['Close Price'][x] < df2['Upper Band'][x] and df2['Close Price'][x] >= df2['Middle Band'][x]:\n",
    "        df2['Actual_Call'][x] = 'Hold Short/ Liquidate Buy'\n",
    "    elif df2['Close Price'][x] > df2['Upper Band'][x]:\n",
    "        df2['Actual_Call'][x] = 'Short'\n",
    "    else:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Symbol                    0\n",
       "Series                    0\n",
       "Date                      0\n",
       "Prev Close                0\n",
       "Open Price                0\n",
       "High Price                0\n",
       "Low Price                 0\n",
       "Last Price                0\n",
       "Close Price               0\n",
       "Average Price             0\n",
       "Total Traded Quantity     0\n",
       "Turnover                  0\n",
       "No. of Trades             0\n",
       "Deliverable Qty           0\n",
       "% Dly Qt to Traded Qty    0\n",
       "Lower Band                0\n",
       "Middle Band               0\n",
       "Upper Band                0\n",
       "Call                      0\n",
       "Actual_Call               0\n",
       "dtype: int64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df2.isnull().sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Classification Report: \n",
      "                           precision    recall  f1-score   support\n",
      "\n",
      "                      Buy       1.00      0.52      0.69        23\n",
      "Hold Buy/ Liquidate Short       0.95      0.89      0.92       244\n",
      "Hold Short/ Liquidate Buy       0.86      1.00      0.93       198\n",
      "                    Short       1.00      0.69      0.81        16\n",
      "\n",
      "                 accuracy                           0.91       481\n",
      "                macro avg       0.95      0.77      0.84       481\n",
      "             weighted avg       0.92      0.91      0.91       481\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(\"Classification Report: \")\n",
    "print(classification_report(df2['Actual_Call'], df2['Call']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### 91% Accuracy achieved while predicting stocks for IDBI Bank Ltd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#confusion matrix\n",
    "scikitplot.metrics.plot_confusion_matrix(df2['Actual_Call'], df2['Call'], x_tick_rotation = 90)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "call = df2['Call'].value_counts()\n",
    "a_call = df2['Actual_Call'].value_counts()\n",
    "y = []\n",
    "k =[]\n",
    "for i in range(len(call)):\n",
    "    y.append(call[i])\n",
    "    k.append(a_call[i])\n",
    "x = [\"Hold Short/ Liquidate Buy\",\"Hold Buy/ Liquidate Short\",\"Buy\",\"Short\"]\n",
    "\n",
    "plt.figure(figsize = (12,6))\n",
    "barWidth = 0.25\n",
    " \n",
    "# set height of bar\n",
    "bars1 = y\n",
    "bars2 = k\n",
    "\n",
    " \n",
    "# Set position of bar on X axis\n",
    "r1 = np.arange(len(bars1))\n",
    "r2 = [x + barWidth for x in r1]\n",
    "\n",
    "\n",
    "# Make the plot\n",
    "plt.bar(r1, bars1, width=barWidth, edgecolor='white', label='Predicted Call')\n",
    "plt.bar(r2, bars2, width=barWidth, edgecolor='white', label='Actual Call')\n",
    " \n",
    "# Add xticks on the middle of the group bars\n",
    "plt.xlabel('Calls', fontweight='bold')\n",
    "plt.xticks([r + barWidth for r in range(len(bars1))], x)\n",
    " \n",
    "# Create legend & Show graphic\n",
    "plt.legend()\n",
    "plt.title(\"Comparison between Actual Call & Predicted Call\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Query 4.2 \n",
    "Now, we'll again utilize classification to make a trade call, and measure the efficiency of our trading algorithm over the past two years. For this assignment , we will use RandomForest classifier."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.2.1\n",
    "Import the stock data file of your choice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Previously Working with GMR\n",
    "df = pd.read_csv(\"Datasets/MID_CAP/GMRINFRA.csv\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.2.2\n",
    "Define 4 new columns , whose values are:\n",
    "1. % change between Open and Close price for the day\n",
    "2. % change between Low and High price for the day\n",
    "3. 5 day rolling mean of the day to day % change in Close Price\n",
    "4. 5 day rolling std of the day to day % change in Close Price "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Day_Perc_Change'] = df['Close Price'].pct_change(periods = 1)\n",
    "df['Day_Perc_Change'] = df['Day_Perc_Change']*100\n",
    "number1 = df.loc[df.index,'Close Price'].iat[0]\n",
    "number2 = df.loc[df.index,'Prev Close'].iat[0]\n",
    "number = (number1 - number2)\n",
    "number = number/number2\n",
    "number = number * 100\n",
    "df['Day_Perc_Change'][0] = number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Perc_Chng_OC'] = np.nan\n",
    "for x in range(df.shape[0]):\n",
    "    number2 = df['Open Price'][x]\n",
    "    number1 = df['Close Price'][x]\n",
    "    number = (number1 - number2)\n",
    "    number = number/number2\n",
    "    number = number * 100\n",
    "    df['Perc_Chng_OC'][x] = number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Perc_Chng_HL'] = np.nan\n",
    "for x in range(df.shape[0]):\n",
    "    number2 = df['Low Price'][x]\n",
    "    number1 = df['High Price'][x]\n",
    "    number = (number1 - number2)\n",
    "    number = number/number2\n",
    "    number = number * 100\n",
    "    df['Perc_Chng_HL'][x] = number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Rolling Mean'] = df['Day_Perc_Change'].rolling(5,min_periods=5).mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Rolling Std'] = df['Day_Perc_Change'].rolling(5,min_periods=5).std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(inplace=True)\n",
    "df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.2.3\n",
    "Create a new column 'Action' whose values are:\n",
    "1. 1 if next day's price(Close) is greater than present day's i.e. Action [ i ] = 1 if Close[ i+1 ] > Close[ i ].\n",
    "2. (-1) if next day's price(Close) is less than present day's i.e. Action [ i ] = (-1) if Close[ i+1 ] < Close[ i ]."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Action'] = np.nan\n",
    "for i in range(df.shape[0]-1):\n",
    "    df['Action'][i] = 1 if df['Close Price'][i+1] > df['Close Price'][i] else -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.dropna(inplace=True)\n",
    "df.reset_index(drop=True, inplace=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.2.4\n",
    "Construct a classification model with the 4 new inputs and 'Action' as target."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split\\\n",
    "(df[['Perc_Chng_OC','Perc_Chng_HL','Rolling Mean','Rolling Std']],df['Action'], test_size=0.267)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tarining score = 0.7150837988826816 , while validation score = 0.5502380952380952\n"
     ]
    }
   ],
   "source": [
    "random_forest =RandomForestClassifier(n_estimators=1000, criterion='entropy', max_depth=5, min_samples_split=2,\n",
    "                           min_samples_leaf=2, max_features='auto', bootstrap=False, oob_score=False, \n",
    "                           n_jobs=1, verbose=0)\n",
    "\n",
    "random_forest.fit(X_train, y_train)\n",
    "Y_pred = random_forest.predict(X_test)\n",
    "\n",
    "result_train = random_forest.score(X_train, y_train)\n",
    "result_val = cross_val_score(random_forest,X_train, y_train, cv=5).mean()\n",
    "\n",
    "print('tarining score = %s , while validation score = %s' %(result_train , result_val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query 4.2.5\n",
    "Check the accuracy of this model , also , plot the net cumulative returns (in %) if we were to follow this algorithmic model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6030534351145038"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "accuracy_score(y_test, Y_pred, normalize=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['Day_Perc_Change'] = df['Day_Perc_Change']/100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['cum_ret'] = 1 + (df['Day_Perc_Change'])\n",
    "df['cum_ret'] = np.cumprod(df['cum_ret'])\n",
    "df['cum_ret'] = 1 - df['cum_ret']\n",
    "df['cum_ret'] = 100 * df['cum_ret']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fab57bddac8>]"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1195.2x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (16.6,6))\n",
    "plt.plot(df['cum_ret'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split\\\n",
    "(df[['Close Price','Rolling Mean','Rolling Std']],df['cum_ret'], test_size=0.123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def performance_metric(y_true, y_predict):\n",
    "    \"\"\" Calculates and returns the performance score between \n",
    "        true and predicted values based on the metric chosen. \"\"\"\n",
    "    # Calculate the performance score between 'y_true' and 'y_predict'\n",
    "    score = r2_score(y_true, y_predict)\n",
    "    \n",
    "    # Return the score\n",
    "    return score\n",
    "\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "\n",
    "def fit_model(X, y):\n",
    "    \"\"\" Performs grid search over the 'max_depth' parameter for a \n",
    "        decision tree regressor trained on the input data [X, y]. \"\"\"\n",
    "    \n",
    "    # Create cross-validation sets from the training data\n",
    "    cv_sets = ShuffleSplit(n_splits=10, test_size = 0.20, random_state = 0)\n",
    "    \n",
    "    # Create a decision tree regressor object\n",
    "    regressor = RandomForestRegressor(n_estimators=100)\n",
    "\n",
    "    # Create a dictionary for the parameter 'max_depth' with a range from 1 to 10\n",
    "    params = {'max_depth' : (1,2,3,4,5,6,7,8,9,10)}\n",
    "    \n",
    "    # Transform 'performance_metric' into a scoring function using 'make_scorer' \n",
    "    scoring_fnc = make_scorer(performance_metric)\n",
    "\n",
    "    # Create the grid search object\n",
    "    grid = GridSearchCV(regressor, params, scoring=scoring_fnc, cv=cv_sets)\n",
    "\n",
    "    # Fit the grid search object to the data to compute the optimal model\n",
    "    grid = grid.fit(X, y)\n",
    "\n",
    "    # Return the optimal model after fitting the data\n",
    "    return grid.best_estimator_\n",
    "\n",
    "# Fit the training data to the model using grid search\n",
    "reg = fit_model(X_train, y_train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7fab57b8bb38>]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(16,6))\n",
    "plt.plot(reg.predict(X_test),'o-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9999569791089163"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "r2_score(y_test.values,reg.predict(X_test))"
   ]
  }
 ],
 "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
}