GOOGLE_STOCK_PREDICTION.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GOOGLE stock 'Open' value prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# All libraries or module used\n",
    "\n",
    "# Stock Data Extractor Libraries\n",
    "import requests\n",
    "import pandas_datareader as pdr\n",
    "from pandas_datareader import data, wb\n",
    "\n",
    "# Data Analysis Essential Libraries\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# Other Libraries\n",
    "import pickle\n",
    "import datetime\n",
    "import math, time\n",
    "from math import sqrt\n",
    "\n",
    "# Scikit Learn Libraries\n",
    "from sklearn import preprocessing\n",
    "from sklearn.externals import joblib\n",
    "from sklearn.metrics import mean_squared_error\n",
    "\n",
    "# Keras Libraries\n",
    "from keras.models import Sequential\n",
    "from keras.layers.recurrent import LSTM\n",
    "from keras.layers.core import Dense, Dropout, Activation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Getting and Saving The stock data of Google\n",
    "# Splitting the data into training and testing data\n",
    "api_key = '' # Get your API key from alphavantage website\n",
    "symbol = \"GOOG\"\n",
    "file_name = symbol+'_stock.csv' \n",
    "\n",
    "try:\n",
    "    data_json = \"https://www.alphavantage.co/query?function=TIME_SERIES_DAILY&symbol={0}&apikey={1}&datatype=csv&outputsize=full\".format(symbol, api_key)\n",
    "    page = requests.get(data_json)\n",
    "    \n",
    "    with open(file_name, 'wb') as file:\n",
    "        file.write(page.content)\n",
    "    dataframe = pd.read_csv(file_name, parse_dates=['timestamp'], index_col=['timestamp'])\n",
    "    dataframe.sort_index(ascending=True, inplace=True)\n",
    "except:\n",
    "    dataframe = pd.read_csv(file_name, parse_dates=['timestamp'], index_col=['timestamp'])\n",
    "    dataframe.sort_index(ascending=True, inplace=True)\n",
    "    \n",
    "train_length = int(0.7 * len(dataframe))\n",
    "df_train = dataframe.iloc[:train_length,[0, 3]]\n",
    "df_test = dataframe.iloc[train_length:,[0, 3]]\n",
    "\n",
    "# df_train = pd.read_csv('GOOG_train.csv', index_col = ['Date'], parse_dates = [\"Date\"], usecols = ['Date', 'Open', 'Close'])\n",
    "# df_train.sort_index(ascending=True, inplace=True)\n",
    "# df_test = pd.read_csv('GOOG_test.csv', index_col = ['Date'], parse_dates = [\"Date\"], usecols = ['Date', 'Open', 'Close'])\n",
    "# df_test.sort_index(ascending=True, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalizing data by dividing 1000\n",
    "df_train = df_train / 1000\n",
    "df_test = df_test / 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## It is set to calculate the first feature as a result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generating training and testing data for feature and label \n",
    "# i.e. Xtrain, ytrain, Xtest, ytest\n",
    "def load_data(stock, seq_len):\n",
    "    amount_of_features = len(stock.columns)\n",
    "    data = stock.as_matrix() #pd.DataFrame(stock)\n",
    "    sequence_length = seq_len\n",
    "    result = []\n",
    "    \n",
    "    row = round(0.9 * data.shape[0])\n",
    "    X_train = []\n",
    "    y_train = []\n",
    "    X_test = []\n",
    "    y_test = []\n",
    "    \n",
    "    for index in range(len(data)):\n",
    "        if index < row:\n",
    "            X_train.append(data[index])\n",
    "            y_train.append(data[index + 1])\n",
    "        else:\n",
    "            X_test.append(data[index])\n",
    "            y_test.append(data[index])\n",
    "            \n",
    "    X_train, y_train, X_test, y_test = np.array(X_train), np.array(y_train), np.array(X_test), np.array(y_test)\n",
    "\n",
    "#     result = np.array(result)\n",
    "#     row = round(0.9 * result.shape[0])\n",
    "#     train = result[:int(row), :]\n",
    "    \n",
    "#     print(train[0])\n",
    "    \n",
    "#     x_train = train[:, 0]\n",
    "#     y_train = train[:, 1][:,0]\n",
    "#     x_test = result[int(row):, 0]\n",
    "#     y_test = result[int(row):, 1][:, 0]\n",
    "\n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], amount_of_features))\n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], amount_of_features))  \n",
    "\n",
    "    return [X_train, y_train, X_test, y_test]\n",
    "\n",
    "\n",
    "def training_data(stock, seq_len):\n",
    "    amount_of_features = len(stock.columns)\n",
    "    data = stock.values\n",
    "    #data_open = stock_open.as_matrix()\n",
    "    \n",
    "    X_train = []\n",
    "    y_train = []\n",
    "    \n",
    "    for index in range(seq_len, len(data)):\n",
    "            X_train.append(data[index - seq_len:index])\n",
    "            y_train.append(data[index][0])\n",
    "            \n",
    "    X_train, y_train= np.array(X_train), np.array(y_train)\n",
    "    \n",
    "    X_train = np.reshape(X_train, (X_train.shape[0], X_train.shape[1], amount_of_features))\n",
    "    \n",
    "    return X_train, y_train\n",
    "\n",
    "def testing_data(stocks_train, stock_test, seq_len):\n",
    "    amount_of_features = len(stock_test.columns)\n",
    "    try:\n",
    "        data = stock_test.open\n",
    "    except:\n",
    "        data = stock_test.Open\n",
    "    \n",
    "    X_test = []    \n",
    "    y_test = data.as_matrix()\n",
    "    \n",
    "    dataset_total = pd.concat((stocks_train, stock_test), axis = 0)\n",
    "    inputs = dataset_total[len(dataset_total) - len(stock_test) - seq_len:].as_matrix()\n",
    "    \n",
    "    for index in range(seq_len, len(stock_test) + seq_len):\n",
    "        X_test.append(inputs[index - seq_len:index])\n",
    "    \n",
    "    X_test, y_test = np.array(X_test), np.array(y_test)\n",
    "    \n",
    "    X_test = np.reshape(X_test, (X_test.shape[0], X_test.shape[1], amount_of_features))\n",
    "    \n",
    "    return X_test, y_test"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Building model functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining Model Structure\n",
    "def build_model(layers):\n",
    "        d = 0.3\n",
    "        model = Sequential()\n",
    "        model.add(LSTM(128, input_shape=(layers[1], layers[0]), return_sequences=True))\n",
    "        model.add(Dropout(d))\n",
    "        model.add(LSTM(64, input_shape=(layers[1], layers[0]), return_sequences=False))\n",
    "        model.add(Dropout(d))\n",
    "        model.add(Dense(16,kernel_initializer='uniform',activation='relu'))        \n",
    "        model.add(Dense(1,kernel_initializer='uniform',activation='relu'))\n",
    "        model.compile(loss='mean_squared_error',optimizer='adam',metrics=['accuracy'])\n",
    "        return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setting X and Y for training and testing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "window = 1\n",
    "X_train, y_train = training_data(df_train, window)\n",
    "X_test, y_test = testing_data(df_train, df_test, window)\n",
    "print(\"\\n\")\n",
    "print(\"X_train\", X_train.shape)\n",
    "print(\"y_train\", y_train.shape)\n",
    "print(\"X_test\", X_test.shape)\n",
    "print(\"y_test\", y_test.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the model sequence structure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Building the model sequence structure\n",
    "model = build_model([len(df_train.columns),window,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Executing the model & RMS/RMSE results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(\n",
    "    X_train,\n",
    "    y_train,\n",
    "    batch_size=512,\n",
    "    epochs=500,\n",
    "    validation_split=0.1,\n",
    "    verbose=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Getting the Accuracy of training data (Performance metric --> MSE)\n",
    "trainScore = model.evaluate(X_train, y_train, verbose=0)\n",
    "print('Train Score: %.2f MSE (%.2f RMSE)' % (trainScore[0], math.sqrt(trainScore[0])))\n",
    "\n",
    "# Getting the Accuracy of testing data (Performance metric --> MSE)\n",
    "testScore = model.evaluate(X_test, y_test, verbose=0)\n",
    "print('Test Score: %.2f MSE (%.2f RMSE)' % (testScore[0], math.sqrt(testScore[0])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for diffrence between actual value and predicted value \n",
    "# and ratio of actual value to the predicted value\n",
    "diff=[]\n",
    "ratio=[]\n",
    "p = model.predict(X_test)\n",
    "for u in range(len(y_test)):\n",
    "    pr = p[u][0]\n",
    "    ratio.append((y_test[u]/pr)-1)\n",
    "    diff.append(abs(y_test[u]- pr))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Predictions vs Real results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting the Actual vs Predicted Result\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(p,color='red', label='predictes Stock Price')\n",
    "plt.plot(y_test,color='blue', label='Actual Stock Price')\n",
    "plt.legend(loc='upper left')\n",
    "plt.xlabel(\"Day\")\n",
    "plt.ylabel(\"Values\")\n",
    "plt.title(\"LSTM Stock Prediction\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# plotting the difference and ratio of actual and predicted values\n",
    "plt.figure(figsize=(10, 5))\n",
    "plt.plot(ratio,color='red', label='ratio')\n",
    "plt.plot(diff,color='blue', label='diff')\n",
    "plt.legend(loc='upper left')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.mean(np.abs(p - y_test.reshape(-1, 1)) < 0.02)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(df_test.tail(10), X_test[-10:], y_test.reshape(-1, 1)[-10:], p[-10:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "try:\n",
    "    all_data = np.append(df_train['Open'].values, df_test['Open'].values)\n",
    "    all_data = np.append(all_data, model.predict(np.array([df_test.values[-window:]])))\n",
    "    all_data\n",
    "except:\n",
    "    all_data = np.append(df_train['open'].values, df_test['open'].values)\n",
    "    all_data = np.append(all_data, model.predict(np.array([df_test.values[-window:]])))\n",
    "    all_data\n",
    "\n",
    "all_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Saving the training, testing, and window size\n",
    "# Also Saving the model \n",
    "joblib.dump(df_train, \"training_data.pkl\")\n",
    "joblib.dump(df_test, \"testing_data.pkl\")\n",
    "joblib.dump(window, \"actual_window.pkl\")\n",
    "model.save('modd.hdf5')"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}