Predicting Crypto Currencies Price using LSTM.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "vUxZ6yCDQVw7"
   },
   "source": [
    "# Bitcoin and Ethereum price prediction with RNN LSTM\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DKA1cgltl72z"
   },
   "source": [
    "Importing necessary libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "code",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 34,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2731,
     "status": "ok",
     "timestamp": 1520965186750,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "R312y6JSrGR9",
    "outputId": "906086a8-6793-46b6-a933-0738048dbb2a"
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import time\n",
    "import datetime\n",
    "import gc\n",
    "import keras\n",
    "from keras.models import Sequential\n",
    "from keras.layers import Activation,Dense,LSTM,Dropout\n",
    "\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "UPqh481vmI6j"
   },
   "source": [
    "Setting up hyper parameters and global variables for our model:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "yu13w2SuugZw"
   },
   "outputs": [],
   "source": [
    "neurons = 512                 # number of hidden units in the LSTM layer\n",
    "activation_function = 'tanh'  # activation function for LSTM and Dense layer\n",
    "loss = 'mse'                  # loss function for calculating the gradient, in this case Mean Squared Error\n",
    "optimizer= 'adam'             # optimizer for appljying gradient decent\n",
    "dropout = 0.25                # dropout ratio used after each LSTM layer to avoid overfitting\n",
    "batch_size = 128              \n",
    "epochs = 53                  \n",
    "window_len = 7               # is an intiger to be used as the look back window for creating a single input sample.\n",
    "training_size = 0.8           # porportion of data to be used for training\n",
    "merge_date = '2016-01-01'     # the earliest date which we have data for both ETH and BTC or any other provided coin"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "gS2JkcmJmQa9"
   },
   "source": [
    "Here we will define functions for preprocessing our data as well as the build_model function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "Qm_1vhACbDJe"
   },
   "outputs": [],
   "source": [
    "def get_market_data(market, tag=True):\n",
    "  \"\"\"\n",
    "  market: the full name of the cryptocurrency as spelled on coinmarketcap.com. eg.: 'bitcoin'\n",
    "  tag: eg.: 'btc', if provided it will add a tag to the name of every column.\n",
    "  returns: panda DataFrame\n",
    "  This function will use the coinmarketcap.com url for provided coin/token page. \n",
    "  Reads the OHLCV and Market Cap.\n",
    "  Converts the date format to be readable. \n",
    "  Makes sure that the data is consistant by converting non_numeric values to a number very close to 0.\n",
    "  And finally tags each columns if provided.\n",
    "  \"\"\"\n",
    "  market_data = pd.read_html(\"https://coinmarketcap.com/currencies/\" + market + \n",
    "                             \"/historical-data/?start=20130428&end=\"+time.strftime(\"%Y%m%d\"), flavor='html5lib')[0]\n",
    "  market_data = market_data.assign(Date=pd.to_datetime(market_data['Date']))  \n",
    "  market_data['Volume'] = (pd.to_numeric(market_data['Volume'], errors='coerce').fillna(0))\n",
    "  if tag:\n",
    "    market_data.columns = [market_data.columns[0]] + [tag + '_' + i for i in market_data.columns[1:]]\n",
    "  return market_data\n",
    "\n",
    "\n",
    "def merge_data(a, b, from_date=merge_date):\n",
    "  \"\"\"\n",
    "  a: first DataFrame\n",
    "  b: second DataFrame\n",
    "  from_date: includes the data from the provided date and drops the any data before that date.\n",
    "  returns merged data as Pandas DataFrame\n",
    "  \"\"\"\n",
    "  merged_data = pd.merge(a, b, on=['Date'])\n",
    "  merged_data = merged_data[merged_data['Date'] >= from_date]\n",
    "  return merged_data\n",
    "\n",
    "\n",
    "def add_volatility(data, coins=['BTC', 'ETH']):\n",
    "  \"\"\"\n",
    "  data: input data, pandas DataFrame\n",
    "  coins: default is for 'btc and 'eth'. It could be changed as needed\n",
    "  This function calculates the volatility and close_off_high of each given coin in 24 hours, \n",
    "  and adds the result as new columns to the DataFrame.\n",
    "  Return: DataFrame with added columns\n",
    "  \"\"\"\n",
    "  for coin in coins:\n",
    "    # calculate the daily change\n",
    "    kwargs = {coin + '_change': lambda x: (x[coin + '_Close'] - x[coin + '_Open']) / x[coin + '_Open'],\n",
    "             coin + '_close_off_high': lambda x: 2*(x[coin + '_High'] - x[coin + '_Close']) / (x[coin + '_High'] - x[coin + '_Low']) - 1,\n",
    "             coin + '_volatility': lambda x: (x[coin + '_High'] - x[coin + '_Low']) / (x[coin + '_Open'])}\n",
    "    data = data.assign(**kwargs)\n",
    "  return data\n",
    "\n",
    "\n",
    "def create_model_data(data):\n",
    "  \"\"\"\n",
    "  data: pandas DataFrame\n",
    "  This function drops unnecessary columns and reverses the order of DataFrame based on decending dates.\n",
    "  Return: pandas DataFrame\n",
    "  \"\"\"\n",
    "  #data = data[['Date']+[coin+metric for coin in ['btc_', 'eth_'] for metric in ['Close','Volume','close_off_high','volatility']]]\n",
    "  data = data[['Date']+[coin+metric for coin in ['BTC_', 'ETH_'] for metric in ['Close**','Volume']]]\n",
    "  data = data.sort_values(by='Date')\n",
    "  return data\n",
    "\n",
    "\n",
    "def split_data(data, training_size=0.8):\n",
    "  \"\"\"\n",
    "  data: Pandas Dataframe\n",
    "  training_size: proportion of the data to be used for training\n",
    "  This function splits the data into training_set and test_set based on the given training_size\n",
    "  Return: train_set and test_set as pandas DataFrame\n",
    "  \"\"\"\n",
    "  return data[:int(training_size*len(data))], data[int(training_size*len(data)):]\n",
    "\n",
    "\n",
    "def create_inputs(data, coins=['BTC', 'ETH'], window_len=window_len):\n",
    "  \"\"\"\n",
    "  data: pandas DataFrame, this could be either training_set or test_set\n",
    "  coins: coin datas which will be used as the input. Default is 'btc', 'eth'\n",
    "  window_len: is an intiger to be used as the look back window for creating a single input sample.\n",
    "  This function will create input array X from the given dataset and will normalize 'Close' and 'Volume' between 0 and 1\n",
    "  Return: X, the input for our model as a python list which later needs to be converted to numpy array.\n",
    "  \"\"\"\n",
    "  norm_cols = [coin + metric for coin in coins for metric in ['_Close**', '_Volume']]\n",
    "  inputs = []\n",
    "  for i in range(len(data) - window_len):\n",
    "    temp_set = data[i:(i + window_len)].copy()\n",
    "    inputs.append(temp_set)\n",
    "    for col in norm_cols:\n",
    "      inputs[i].loc[:, col] = inputs[i].loc[:, col] / inputs[i].loc[:, col].iloc[0] - 1  \n",
    "  return inputs\n",
    "\n",
    "\n",
    "def create_outputs(data, coin, window_len=window_len):\n",
    "  \"\"\"\n",
    "  data: pandas DataFrame, this could be either training_set or test_set\n",
    "  coin: the target coin in which we need to create the output labels for\n",
    "  window_len: is an intiger to be used as the look back window for creating a single input sample.\n",
    "  This function will create the labels array for our training and validation and normalize it between 0 and 1\n",
    "  Return: Normalized numpy array for 'Close' prices of the given coin\n",
    "  \"\"\"\n",
    "  return (data[coin + '_Close**'][window_len:].values / data[coin + '_Close**'][:-window_len].values) - 1\n",
    "\n",
    "\n",
    "def to_array(data):\n",
    "  \"\"\"\n",
    "  data: DataFrame\n",
    "  This function will convert list of inputs to a numpy array\n",
    "  Return: numpy array\n",
    "  \"\"\"\n",
    "  x = [np.array(data[i]) for i in range (len(data))]\n",
    "  return np.array(x)\n",
    "\n",
    "\n",
    "def build_model(inputs, output_size, neurons, activ_func=activation_function, dropout=dropout, loss=loss, optimizer=optimizer):\n",
    "  \"\"\"\n",
    "  inputs: input data as numpy array\n",
    "  output_size: number of predictions per input sample\n",
    "  neurons: number of neurons/ units in the LSTM layer\n",
    "  active_func: Activation function to be used in LSTM layers and Dense layer\n",
    "  dropout: dropout ration, default is 0.25\n",
    "  loss: loss function for calculating the gradient\n",
    "  optimizer: type of optimizer to backpropagate the gradient\n",
    "  This function will build 3 layered RNN model with LSTM cells with dripouts after each LSTM layer \n",
    "  and finally a dense layer to produce the output using keras' sequential model.\n",
    "  Return: Keras sequential model and model summary\n",
    "  \"\"\"\n",
    "  model = Sequential()\n",
    "  model.add(LSTM(neurons, return_sequences=True, input_shape=(inputs.shape[1], inputs.shape[2]), activation=activ_func))\n",
    "  model.add(Dropout(dropout))\n",
    "  model.add(LSTM(neurons, return_sequences=True, activation=activ_func))\n",
    "  model.add(Dropout(dropout))\n",
    "  model.add(LSTM(neurons, activation=activ_func))\n",
    "  model.add(Dropout(dropout))\n",
    "  model.add(Dense(units=output_size))\n",
    "  model.add(Activation(activ_func))\n",
    "  model.compile(loss=loss, optimizer=optimizer, metrics=['mae'])\n",
    "  model.summary()\n",
    "  return model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "6n_vvOcsmcSg"
   },
   "source": [
    "Below are the functions for plotting market data and the results after the training:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "auwt63XLkuTD"
   },
   "outputs": [],
   "source": [
    "def show_plot(data, tag):\n",
    "  fig, (ax1, ax2) = plt.subplots(2,1, gridspec_kw = {'height_ratios':[3, 1]})\n",
    "  ax1.set_ylabel('Closing Price ($)',fontsize=12)\n",
    "  ax2.set_ylabel('Volume ($ bn)',fontsize=12)\n",
    "  ax2.set_yticks([int('%d000000000'%i) for i in range(10)])\n",
    "  ax2.set_yticklabels(range(10))\n",
    "  ax1.set_xticks([datetime.date(i,j,1) for i in range(2013,2019) for j in [1,7]])\n",
    "  ax1.set_xticklabels('')\n",
    "  ax2.set_xticks([datetime.date(i,j,1) for i in range(2013,2019) for j in [1,7]])\n",
    "  ax2.set_xticklabels([datetime.date(i,j,1).strftime('%b %Y')  for i in range(2013,2019) for j in [1,7]])\n",
    "  ax1.plot(data['Date'].astype(datetime.datetime),data[tag +'_Open*'])\n",
    "  ax2.bar(data['Date'].astype(datetime.datetime).values, data[tag +'_Volume'].values)\n",
    "  fig.tight_layout()\n",
    "  plt.show()\n",
    "  \n",
    "\n",
    "def date_labels():\n",
    "  last_date = market_data.iloc[0, 0]\n",
    "  date_list = [last_date - datetime.timedelta(days=x) for x in range(len(X_test))]\n",
    "  return[date.strftime('%m/%d/%Y') for date in date_list][::-1]\n",
    "\n",
    "\n",
    "def plot_results(history, model, Y_target, coin):\n",
    "  plt.figure(figsize=(25, 20))\n",
    "  plt.subplot(311)\n",
    "  plt.plot(history.epoch, history.history['loss'], )\n",
    "  plt.plot(history.epoch, history.history['val_loss'])\n",
    "  plt.xlabel('Number of Epochs')\n",
    "  plt.ylabel('Loss')\n",
    "  plt.title(coin + ' Model Loss')\n",
    "  plt.legend(['Training', 'Test'])\n",
    "\n",
    "  plt.subplot(312)\n",
    "  plt.plot(Y_target)\n",
    "  plt.plot(model.predict(X_train))\n",
    "  plt.xlabel('Dates')\n",
    "  plt.ylabel('Price')\n",
    "  plt.title(coin + ' Single Point Price Prediction on Training Set')\n",
    "  plt.legend(['Actual','Predicted'])\n",
    "\n",
    "  ax1 = plt.subplot(313)\n",
    "  plt.plot(test_set[coin + '_Close**'][window_len:].values.tolist())\n",
    "  plt.plot(((np.transpose(model.predict(X_test)) + 1) * test_set[coin + '_Close**'].values[:-window_len])[0])\n",
    "  plt.xlabel('Dates')\n",
    "  plt.ylabel('Price')\n",
    "  plt.title(coin + ' Single Point Price Prediction on Test Set')\n",
    "  plt.legend(['Actual','Predicted'])\n",
    "  \n",
    "  date_list = date_labels()\n",
    "  ax1.set_xticks([x for x in range(len(date_list))])\n",
    "  for label in ax1.set_xticklabels([date for date in date_list], rotation='vertical')[::2]:\n",
    "    label.set_visible(False)\n",
    "\n",
    "  plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "hKeDTnhSmkGz"
   },
   "source": [
    "Load the market data into variables *btc_data* and *eth_data*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "POobtVVWYigo"
   },
   "outputs": [],
   "source": [
    "btc_data = get_market_data(\"bitcoin\", tag='BTC')\n",
    "eth_data = get_market_data(\"ethereum\", tag='ETH')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 204,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 285,
     "status": "ok",
     "timestamp": 1520965195498,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "cs-Y0-68Sfrd",
    "outputId": "b1039d26-b1f2-4f20-e682-d5a225b36110"
   },
   "outputs": [],
   "source": [
    "btc_data.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 577,
     "output_extras": [
      {
       "item_id": 1
      },
      {
       "item_id": 2
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 6308,
     "status": "ok",
     "timestamp": 1520965201973,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "rO60a_-r6svn",
    "outputId": "d7be3c2b-6996-48f3-8768-3bac259f7ab3"
   },
   "outputs": [],
   "source": [
    "show_plot(btc_data, tag='BTC')\n",
    "show_plot(eth_data, tag='ETH')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "DKSzKGR4myVi"
   },
   "source": [
    "Merging the BTC and ETH data and splitting them to training and test sets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     }
    },
    "colab_type": "code",
    "id": "0xM2ct_ve1lH"
   },
   "outputs": [],
   "source": [
    "market_data = merge_data(btc_data, eth_data)\n",
    "model_data = create_model_data(market_data)\n",
    "train_set, test_set = split_data(model_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 204,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 283,
     "status": "ok",
     "timestamp": 1520965202887,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "Qnqb06x0gGfe",
    "outputId": "fa867060-ed9d-4609-9ada-039f71b66af9"
   },
   "outputs": [],
   "source": [
    "model_data.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "Q8Zbhe4_m7qY"
   },
   "source": [
    "Pre-processing data and producing inputs and target outputs:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "code",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 51,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 3649,
     "status": "ok",
     "timestamp": 1520965206712,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "tKnWAnttdNQP",
    "outputId": "31dc59f9-f4a2-48fd-dfb1-62e6b5904497"
   },
   "outputs": [],
   "source": [
    "train_set = train_set.drop('Date', 1)\n",
    "test_set = test_set.drop('Date', 1)\n",
    "\n",
    "X_train = create_inputs(train_set)\n",
    "Y_train_btc = create_outputs(train_set, coin='BTC')\n",
    "X_test = create_inputs(test_set)\n",
    "Y_test_btc = create_outputs(test_set, coin='BTC')\n",
    "\n",
    "Y_train_eth = create_outputs(train_set, coin='ETH')\n",
    "Y_test_eth = create_outputs(test_set, coin='ETH')\n",
    "\n",
    "X_train, X_test = to_array(X_train), to_array(X_test)\n",
    "\n",
    "print (np.shape(X_train), np.shape(X_test), np.shape(Y_train_btc), np.shape(Y_test_btc))\n",
    "print (np.shape(X_train), np.shape(X_test), np.shape(Y_train_eth), np.shape(Y_test_eth))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "d0Lk7SBinKlN"
   },
   "source": [
    "Initializing the model and training it for predicting BTC price for next day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 2247,
     "output_extras": [
      {
       "item_id": 17
      },
      {
       "item_id": 38
      },
      {
       "item_id": 60
      },
      {
       "item_id": 83
      },
      {
       "item_id": 92
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 28337,
     "status": "ok",
     "timestamp": 1520965235064,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "vtU0NZP-JQLq",
    "outputId": "a2ca67b5-7e94-499d-c3ac-32b88d785476"
   },
   "outputs": [],
   "source": [
    "# clean up the memory\n",
    "gc.collect()\n",
    "\n",
    "# random seed for reproducibility\n",
    "np.random.seed(202)\n",
    "\n",
    "# initialise model architecture\n",
    "btc_model = build_model(X_train, output_size=1, neurons=neurons)\n",
    "\n",
    "# train model on data\n",
    "btc_history = btc_model.fit(X_train, Y_train_btc, epochs=epochs, batch_size=batch_size, verbose=1, validation_data=(X_test, Y_test_btc), shuffle=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "3VcD7gcXnVYP"
   },
   "source": [
    "Plot the results:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 1204,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2840,
     "status": "ok",
     "timestamp": 1520965237931,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "2DJ7tz97AAIC",
    "outputId": "ebb16531-2918-4b72-d936-9e7fe46892a6"
   },
   "outputs": [],
   "source": [
    "plot_results(btc_history, btc_model, Y_train_btc, coin='BTC')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "btc_model.save(\"RNN_model_btc.h5\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "colab_type": "text",
    "id": "mWsBSJltncWn"
   },
   "source": [
    "Initializing the model and training it for predicting ETH price for next day:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "cellView": "code",
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 2247,
     "output_extras": [
      {
       "item_id": 16
      },
      {
       "item_id": 36
      },
      {
       "item_id": 57
      },
      {
       "item_id": 81
      },
      {
       "item_id": 89
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 28323,
     "status": "ok",
     "timestamp": 1520965266341,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "2_f1N-xn0jOh",
    "outputId": "a27e3f77-9aec-4866-aa24-7bd5155de285"
   },
   "outputs": [],
   "source": [
    "# clean up the memory\n",
    "gc.collect()\n",
    "\n",
    "# random seed for reproducibility\n",
    "np.random.seed(202)\n",
    "\n",
    "# initialise model architecture\n",
    "eth_model = build_model(X_train, output_size=1, neurons=neurons)\n",
    "\n",
    "# train model on data\n",
    "eth_history = eth_model.fit(X_train, Y_train_eth, epochs=epochs, batch_size=batch_size, verbose=1, validation_data=(X_test, Y_test_eth), shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "autoexec": {
      "startup": false,
      "wait_interval": 0
     },
     "base_uri": "https://localhost:8080/",
     "height": 1204,
     "output_extras": [
      {
       "item_id": 1
      }
     ]
    },
    "colab_type": "code",
    "executionInfo": {
     "elapsed": 2934,
     "status": "ok",
     "timestamp": 1520965269299,
     "user": {
      "displayName": "Siavash Fahimi",
      "photoUrl": "//lh6.googleusercontent.com/-up4qQrxDTS8/AAAAAAAAAAI/AAAAAAAAAA8/Ur690oI3y3o/s50-c-k-no/photo.jpg",
      "userId": "115818752764157619428"
     },
     "user_tz": 420
    },
    "id": "BgBbhBec1pMf",
    "outputId": "0366d5ea-a3e1-4364-d5ed-e4265779b34d"
   },
   "outputs": [],
   "source": [
    "plot_results(eth_history, eth_model, Y_train_eth, coin='ETH')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eth_model.save(\"RNN_model_eth.h5\")"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "default_view": {},
   "name": "lstm-crypto-price-prediction.ipynb",
   "provenance": [],
   "version": "0.3.2",
   "views": {}
  },
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}