01_test_end_to_end_compare_models.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# End-to-end example: Compare models, direct prediction"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import ccxt\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import requests\n",
    "from sklearn.multioutput import RegressorChain\n",
    "from tensorflow import keras\n",
    "from tensorflow.keras import Sequential, Model\n",
    "from tensorflow.keras.layers import Input, Dense\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "# import libs helpers\n",
    "from helpers.ocean_helpers import calc_nmse "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "cex_x = ccxt.binance().fetch_ohlcv('ETH/USDT', '1h')\n",
    "\n",
    "# create a Data Frame with two columns [date,eth-prices] with dates given in intervals of 1-hour\n",
    "import pandas as pd\n",
    "data = pd.DataFrame(cex_x, columns=['date', 'open', 'max', 'min', 'close', 'volume'])\n",
    "data['date'] = pd.to_datetime(data['date'],unit='ms')\n",
    "\n",
    "# Divide the data in training and testing set. Because the data has temporal structure, we split the data in two blocks, vs. selecting randomly.\n",
    "# 90% of the data is used for training and 10 is used for testing\n",
    "train_rate = 0.9\n",
    "n = data.shape[0]\n",
    "ntrain = int(np.floor(n*train_rate))\n",
    "train_data = data.iloc[0:ntrain,:]\n",
    "test_data = data.iloc[ntrain:,:]\n",
    "\n",
    "# Create feature vectors\n",
    "# - Define how many samples in the past are used to predict future values. \n",
    "# - This also defines the number of smaples to be predicted in the future.\n",
    "max_lag = 12 \n",
    "\n",
    "# Create feature vectors with 12 columns, each representing a time-lag from the current time point\n",
    "# - That is: x(t-1), x(t-2)...x(t-12) for close and open values (different features could be grouped using the same logic)\n",
    "full_train_close = pd.concat([train_data['close'].shift(i) for i in range(0,max_lag)],axis=1).dropna().values\n",
    "full_train_open = pd.concat([train_data['open'].shift(i) for i in range(0,max_lag)],axis=1).dropna().values\n",
    "# targets are multivariate, with the values of eth from 1 - 12 hours ahead of the curent time\n",
    "y_train = full_train_close[max_lag:,:]\n",
    "# train set is lagged with respect to the targets\n",
    "x_train = np.concatenate((full_train_close[0:-max_lag,:],full_train_open[0:-max_lag,:]),axis=1)\n",
    "\n",
    "# Repeat the feature vector creation as above for the test set\n",
    "full_test_close = pd.concat([test_data['close'].shift(i) for i in range(0,max_lag)],axis=1).dropna().values\n",
    "full_test_open = pd.concat([test_data['open'].shift(i) for i in range(0,max_lag)],axis=1).dropna().values\n",
    "y_test = full_test_close[max_lag:,:]\n",
    "x_test = np.concatenate((full_test_close[0:-max_lag,:],full_test_open[0:-max_lag,:]),axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "500"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>date</th>\n",
       "      <th>open</th>\n",
       "      <th>max</th>\n",
       "      <th>min</th>\n",
       "      <th>close</th>\n",
       "      <th>volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2023-01-18 22:00:00</td>\n",
       "      <td>1528.46</td>\n",
       "      <td>1531.67</td>\n",
       "      <td>1517.39</td>\n",
       "      <td>1531.38</td>\n",
       "      <td>12766.0369</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2023-01-18 23:00:00</td>\n",
       "      <td>1531.39</td>\n",
       "      <td>1533.28</td>\n",
       "      <td>1507.90</td>\n",
       "      <td>1511.43</td>\n",
       "      <td>21837.7252</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2023-01-19 00:00:00</td>\n",
       "      <td>1511.44</td>\n",
       "      <td>1523.25</td>\n",
       "      <td>1509.15</td>\n",
       "      <td>1516.26</td>\n",
       "      <td>18982.5522</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2023-01-19 01:00:00</td>\n",
       "      <td>1516.25</td>\n",
       "      <td>1523.80</td>\n",
       "      <td>1515.51</td>\n",
       "      <td>1518.14</td>\n",
       "      <td>9312.9368</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2023-01-19 02:00:00</td>\n",
       "      <td>1518.15</td>\n",
       "      <td>1526.38</td>\n",
       "      <td>1513.91</td>\n",
       "      <td>1525.07</td>\n",
       "      <td>9716.0774</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>495</th>\n",
       "      <td>2023-02-08 13:00:00</td>\n",
       "      <td>1671.90</td>\n",
       "      <td>1676.44</td>\n",
       "      <td>1668.30</td>\n",
       "      <td>1674.64</td>\n",
       "      <td>18216.3982</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>496</th>\n",
       "      <td>2023-02-08 14:00:00</td>\n",
       "      <td>1674.64</td>\n",
       "      <td>1681.98</td>\n",
       "      <td>1661.68</td>\n",
       "      <td>1671.28</td>\n",
       "      <td>31971.2240</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>497</th>\n",
       "      <td>2023-02-08 15:00:00</td>\n",
       "      <td>1671.28</td>\n",
       "      <td>1671.29</td>\n",
       "      <td>1649.51</td>\n",
       "      <td>1653.08</td>\n",
       "      <td>40209.5068</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>498</th>\n",
       "      <td>2023-02-08 16:00:00</td>\n",
       "      <td>1653.08</td>\n",
       "      <td>1654.85</td>\n",
       "      <td>1630.47</td>\n",
       "      <td>1653.47</td>\n",
       "      <td>55209.7895</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>499</th>\n",
       "      <td>2023-02-08 17:00:00</td>\n",
       "      <td>1653.47</td>\n",
       "      <td>1660.00</td>\n",
       "      <td>1647.37</td>\n",
       "      <td>1650.51</td>\n",
       "      <td>17338.8772</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>500 rows × 6 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "                   date     open      max      min    close      volume\n",
       "0   2023-01-18 22:00:00  1528.46  1531.67  1517.39  1531.38  12766.0369\n",
       "1   2023-01-18 23:00:00  1531.39  1533.28  1507.90  1511.43  21837.7252\n",
       "2   2023-01-19 00:00:00  1511.44  1523.25  1509.15  1516.26  18982.5522\n",
       "3   2023-01-19 01:00:00  1516.25  1523.80  1515.51  1518.14   9312.9368\n",
       "4   2023-01-19 02:00:00  1518.15  1526.38  1513.91  1525.07   9716.0774\n",
       "..                  ...      ...      ...      ...      ...         ...\n",
       "495 2023-02-08 13:00:00  1671.90  1676.44  1668.30  1674.64  18216.3982\n",
       "496 2023-02-08 14:00:00  1674.64  1681.98  1661.68  1671.28  31971.2240\n",
       "497 2023-02-08 15:00:00  1671.28  1671.29  1649.51  1653.08  40209.5068\n",
       "498 2023-02-08 16:00:00  1653.08  1654.85  1630.47  1653.47  55209.7895\n",
       "499 2023-02-08 17:00:00  1653.47  1660.00  1647.37  1650.51  17338.8772\n",
       "\n",
       "[500 rows x 6 columns]"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Metal device set to: Apple M1 Pro\n",
      "\n",
      "systemMemory: 32.00 GB\n",
      "maxCacheSize: 10.67 GB\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-08 11:19:11.654678: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:305] Could not identify NUMA node of platform GPU ID 0, defaulting to 0. Your kernel may not have been built with NUMA support.\n",
      "2023-02-08 11:19:11.655315: I tensorflow/core/common_runtime/pluggable_device/pluggable_device_factory.cc:271] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 0 MB memory) -> physical PluggableDevice (device: 0, name: METAL, pci bus id: <undefined>)\n",
      "2023-02-08 11:19:11.920700: W tensorflow/core/platform/profile_utils/cpu_utils.cc:128] Failed to get CPU frequency: 0 Hz\n",
      "2023-02-08 11:19:12.211775: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n",
      "2023-02-08 11:19:12.964424: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1/1 [==============================] - 0s 45ms/step\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2023-02-08 11:19:29.419637: I tensorflow/core/grappler/optimizers/custom_graph_optimizer_registry.cc:113] Plugin optimizer for device_type GPU is enabled.\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create models\n",
    "\n",
    "\n",
    "# regression using a base estimator and RegressionChain\n",
    "def fit_and_predict_reg(base_model,x_train,y_train,x_test,y_test):\n",
    "  chain = RegressorChain(base_estimator=base_model).fit(x_train, y_train)  \n",
    "  yhat_test = chain.predict(x_test)\n",
    "  return calc_nmse(y_test,yhat_test)\n",
    "\n",
    "# Neural network using Keras, 2 hidden layers with RELU activations, output layer with linear activations \n",
    "def fit_andpredict_fcnn(x_train,y_train,x_test,y_test):\n",
    "  inputs = Input(shape=(x_train.shape[1],))\n",
    "  x = Dense(128,activation='relu')(inputs)\n",
    "  x = Dense(64,activation='relu')(x)\n",
    "  outputs = Dense(12,activation='linear')(x)\n",
    "  model = Model(inputs=inputs,outputs=outputs)\n",
    "  # set compiling parameters\n",
    "  model.compile( optimizer=\"adam\", loss='mean_absolute_percentage_error',metrics=[])\n",
    "  # Fit model\n",
    "  model.fit(x_train,y_train,batch_size=100, epochs=500, validation_split=0.1, verbose=0)\n",
    "  # predict\n",
    "  yhat_test = model.predict(x_test)\n",
    "  return calc_nmse(y_test,yhat_test)\n",
    "\n",
    "# multi-output linear regression\n",
    "from sklearn.linear_model import LinearRegression \n",
    "linreg = LinearRegression()\n",
    "linreg_error = fit_and_predict_reg(linreg,x_train,y_train,x_test,y_test)\n",
    "\n",
    "# multi-output random forest regression\n",
    "from sklearn.ensemble import RandomForestRegressor\n",
    "from sklearn.datasets import make_regression\n",
    "rfr = RandomForestRegressor(max_depth=10)\n",
    "rfr_error = fit_and_predict_reg(rfr,x_train,y_train,x_test,y_test)\n",
    "\n",
    "# multi-output support vector machines\n",
    "from sklearn.svm import SVR\n",
    "svr = SVR(kernel='rbf', C=1000, epsilon=.1)\n",
    "svr_error = fit_and_predict_reg(svr,x_train,y_train,x_test,y_test)\n",
    "\n",
    "# Dense NN\n",
    "dnn_error = fit_andpredict_fcnn(x_train,y_train,x_test,y_test)\n",
    "\n",
    "\n",
    "# Plot results\n",
    "\n",
    "info = {'LR':linreg_error, 'RFR':rfr_error, 'SVR':svr_error,'NN':dnn_error}\n",
    "methods = list(info.keys())\n",
    "values = list(info.values())\n",
    "  \n",
    "fig = plt.figure(figsize = (10, 5))\n",
    " \n",
    "# creating the bar plot\n",
    "plt.bar(methods, values, color ='maroon', width = 0.4)\n",
    " \n",
    "plt.xlabel(\"Methods\")\n",
    "plt.ylabel(\"NMSE\")\n",
    "plt.title(\"Comparison of different methods for predicting ETH value 1-12 hours ahead\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ocean_tf",
   "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.10.4"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "622fbdc46093ceebca2707ee83e548aa7e8e72b315685cead53b17c59e715f82"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}