2_train_model.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2_train_model.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.model_selection import train_test_split\n",
    "from keras.models import Model\n",
    "from keras.layers import Input\n",
    "from keras.layers import Conv1D\n",
    "from keras.layers import GaussianNoise\n",
    "# from keras.layers import MaxPooling1D\n",
    "from keras.layers import Dense\n",
    "from keras.layers import Flatten\n",
    "from keras.layers import Dropout\n",
    "from keras.layers import concatenate\n",
    "from keras.utils import plot_model\n",
    "from keras import regularizers\n",
    "# from keras import losses\n",
    "# from keras import callbacks\n",
    "# from keras import metrics\n",
    "import keras\n",
    "import pickle\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.metrics import precision_recall_curve"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25232, 20, 41)\n",
      "(25232, 38)\n",
      "(25232, 2)\n",
      "(25232, 2)\n",
      "25232\n",
      "25232\n"
     ]
    }
   ],
   "source": [
    "with open('data/tensors_6.pkl', 'rb') as file:\n",
    "    price_series, time_categories, up_targets, dn_targets = pickle.load(file) \n",
    "\n",
    "with open('data/outcomes_6b.pkl', 'rb') as file:\n",
    "    up_outcomes, dn_outcomes, up_outcomes_passive, dn_outcomes_passive = pickle.load(file) \n",
    "\n",
    "timesteps = price_series.shape[1]\n",
    "channels = price_series.shape[2]\n",
    "time_dim = time_categories.shape[1]\n",
    "\n",
    "print(price_series.shape)\n",
    "print(time_categories.shape)\n",
    "print(up_targets.shape)\n",
    "print(dn_targets.shape)\n",
    "print(len(up_outcomes))\n",
    "print(len(dn_outcomes))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Split Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "RANDOM_SEED = 7\n",
    "TARGETS = dn_targets\n",
    "OUTCOMES = dn_outcomes\n",
    "\n",
    "# Splitting the arrays into train and test sets\n",
    "train_x_price, test_x_price = train_test_split(price_series, test_size=0.2, random_state=RANDOM_SEED)\n",
    "train_x_time, test_x_time = train_test_split(time_categories, test_size=0.2, random_state=RANDOM_SEED)\n",
    "train_y, test_y = train_test_split(TARGETS, test_size=0.2, random_state=RANDOM_SEED)\n",
    "train_outcomes, test_outcomes = train_test_split(OUTCOMES, test_size=0.2, random_state=RANDOM_SEED)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define Multimodal Convolutional Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"model_14\"\n",
      "__________________________________________________________________________________________________\n",
      " Layer (type)                Output Shape                 Param #   Connected to                  \n",
      "==================================================================================================\n",
      " input_9 (InputLayer)        [(None, 20, 41)]             0         []                            \n",
      "                                                                                                  \n",
      " gaussian_noise_8 (Gaussian  (None, 20, 41)               0         ['input_9[0][0]']             \n",
      " Noise)                                                                                           \n",
      "                                                                                                  \n",
      " conv1d_24 (Conv1D)          (None, 20, 1024)             294912    ['gaussian_noise_8[0][0]']    \n",
      "                                                                                                  \n",
      " conv1d_25 (Conv1D)          (None, 20, 1024)             3146752   ['conv1d_24[0][0]']           \n",
      "                                                                                                  \n",
      " conv1d_26 (Conv1D)          (None, 10, 1024)             2097152   ['conv1d_25[0][0]']           \n",
      "                                                                                                  \n",
      " conv1d_27 (Conv1D)          (None, 10, 2048)             6293504   ['conv1d_26[0][0]']           \n",
      "                                                                                                  \n",
      " conv1d_28 (Conv1D)          (None, 5, 2048)              8388608   ['conv1d_27[0][0]']           \n",
      "                                                                                                  \n",
      " conv1d_29 (Conv1D)          (None, 5, 4096)              2516992   ['conv1d_28[0][0]']           \n",
      "                                                          0                                       \n",
      "                                                                                                  \n",
      " input_10 (InputLayer)       [(None, 38)]                 0         []                            \n",
      "                                                                                                  \n",
      " dropout_4 (Dropout)         (None, 5, 4096)              0         ['conv1d_29[0][0]']           \n",
      "                                                                                                  \n",
      " gaussian_noise_9 (Gaussian  (None, 38)                   0         ['input_10[0][0]']            \n",
      " Noise)                                                                                           \n",
      "                                                                                                  \n",
      " flatten_4 (Flatten)         (None, 20480)                0         ['dropout_4[0][0]']           \n",
      "                                                                                                  \n",
      " dense_16 (Dense)            (None, 8)                    312       ['gaussian_noise_9[0][0]']    \n",
      "                                                                                                  \n",
      " concatenate_4 (Concatenate  (None, 20488)                0         ['flatten_4[0][0]',           \n",
      " )                                                                   'dense_16[0][0]']            \n",
      "                                                                                                  \n",
      " dense_17 (Dense)            (None, 1024)                 2098073   ['concatenate_4[0][0]']       \n",
      "                                                          6                                       \n",
      "                                                                                                  \n",
      " dense_18 (Dense)            (None, 512)                  524800    ['dense_17[0][0]']            \n",
      "                                                                                                  \n",
      " dense_19 (Dense)            (None, 2)                    1026      ['dense_18[0][0]']            \n",
      "                                                                                                  \n",
      "==================================================================================================\n",
      "Total params: 66897722 (255.19 MB)\n",
      "Trainable params: 66897722 (255.19 MB)\n",
      "Non-trainable params: 0 (0.00 Byte)\n",
      "__________________________________________________________________________________________________\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "FILTERS = 1024\n",
    "NOISE_SDEV = 0.05\n",
    "DEEP_NOISE_SDEV = 0.05\n",
    "\n",
    "keras.utils.set_random_seed(7)\n",
    "\n",
    "# convolutional branch\n",
    "input_cnn = Input(shape=(timesteps,channels)) \n",
    "\n",
    "noise_cnn = GaussianNoise(stddev=NOISE_SDEV, seed=7)(input_cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS, kernel_size=7, padding='same', \n",
    "             activation='relu', data_format='channels_last',\n",
    "             activity_regularizer=None,\n",
    "             input_shape=(timesteps, channels))(noise_cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS, kernel_size=3, padding='same', \n",
    "             activation='relu', data_format='channels_last', \n",
    "             activity_regularizer=None)(cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS, kernel_size=2, padding='same', strides=2,      # pooling layer\n",
    "             activation='relu', use_bias=False, data_format='channels_last', \n",
    "             activity_regularizer=None)(cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS*2, kernel_size=3, padding='same', \n",
    "             activation='relu', data_format='channels_last', \n",
    "             activity_regularizer=None)(cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS*2, kernel_size=2, padding='same', strides=2,     # pooling layer\n",
    "             activation='relu', use_bias=False, data_format='channels_last',\n",
    "             activity_regularizer=None)(cnn)\n",
    "\n",
    "cnn = Conv1D(filters=FILTERS*4, kernel_size=3, padding='same', \n",
    "             activation='relu', data_format='channels_last', \n",
    "             activity_regularizer=regularizers.L2(0.01))(cnn)\n",
    "\n",
    "cnn = Dropout(0.4)(cnn)\n",
    "cnn = Flatten()(cnn)\n",
    "cnn = Model(inputs=input_cnn, outputs=cnn)\n",
    "\n",
    "# perceptron branch\n",
    "input_mlp = Input(shape=(time_dim,))\n",
    "noise_mlp = GaussianNoise(stddev=DEEP_NOISE_SDEV, seed=7)(input_mlp)\n",
    "mlp = Dense(8, activation='relu', \n",
    "            activity_regularizer=regularizers.L2(0.01))(noise_mlp)\n",
    "mlp = Model(inputs=input_mlp, outputs=mlp)\n",
    "\n",
    "# join branches\n",
    "combined = concatenate([cnn.output, mlp.output])\n",
    "head = Dense(1024, activation='relu')(combined)\n",
    "head = Dense(512, activation='relu')(head)\n",
    "head = Dense(2, activation='softmax')(head)\n",
    "model = Model(inputs=[cnn.input, mlp.input], outputs=head)\n",
    "\n",
    "loss = keras.losses.BinaryFocalCrossentropy(apply_class_balancing=False,    # ideally matches metric, but: https://neptune.ai/blog/implementing-the-macro-f1-score-in-keras\n",
    "                                            alpha=0.25,\n",
    "                                            gamma=2.0)    \n",
    " \n",
    "metric = keras.metrics.F1Score(average='weighted',    \n",
    "                               threshold=None, \n",
    "                               dtype=None)     \n",
    "                                                          \n",
    "model.compile(loss=loss,     \n",
    "              optimizer='adam',     # adadelta or adamax may be better suited?                \n",
    "              metrics=[metric])     # does list block optuna?\n",
    "\n",
    "print(model.summary())\n",
    "\n",
    "# plot_model(model, to_file='models/model_plot.png', \n",
    "#                   show_shapes=True, \n",
    "#                   show_layer_names=True, \n",
    "#                   show_layer_activations=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train And Evaluate Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/25\n",
      "79/79 [==============================] - 888s 11s/step - loss: 0.3029 - f1_score: 0.5922 - val_loss: 0.1802 - val_f1_score: 0.4366\n",
      "Epoch 2/25\n",
      "79/79 [==============================] - 973s 12s/step - loss: 0.2976 - f1_score: 0.5818 - val_loss: 0.1676 - val_f1_score: 0.6443\n",
      "Epoch 3/25\n",
      "79/79 [==============================] - 912s 11s/step - loss: 0.2951 - f1_score: 0.5960 - val_loss: 0.1613 - val_f1_score: 0.6806\n",
      "Epoch 4/25\n",
      "79/79 [==============================] - 852s 11s/step - loss: 0.2912 - f1_score: 0.6026 - val_loss: 0.1520 - val_f1_score: 0.7794\n",
      "Epoch 5/25\n",
      "79/79 [==============================] - 852s 11s/step - loss: 0.2887 - f1_score: 0.5848 - val_loss: 0.1756 - val_f1_score: 0.5071\n",
      "Epoch 6/25\n",
      "79/79 [==============================] - 869s 11s/step - loss: 0.2882 - f1_score: 0.6208 - val_loss: 0.1639 - val_f1_score: 0.6397\n",
      "Epoch 7/25\n",
      "79/79 [==============================] - 881s 11s/step - loss: 0.2843 - f1_score: 0.6481 - val_loss: 0.1738 - val_f1_score: 0.5980\n",
      "Epoch 8/25\n",
      "79/79 [==============================] - 871s 11s/step - loss: 0.2830 - f1_score: 0.6377 - val_loss: 0.1562 - val_f1_score: 0.6947\n",
      "0.15198199450969696 0.7793898582458496\n"
     ]
    }
   ],
   "source": [
    "BATCH_SIZE = 256\n",
    "PATIENCE = 4\n",
    "\n",
    "callback = keras.callbacks.EarlyStopping(monitor=\"val_loss\",  \n",
    "   \t\t\t\t \t\t\t\t\t \t patience=PATIENCE,\n",
    "    \t\t\t \t\t\t\t\t  \t verbose=0,\n",
    "\t\t\t\t \t\t\t\t\t\t restore_best_weights=True,)\n",
    "\n",
    "postive_weight = train_y.sum(axis=0)[0] / train_y.sum(axis=0)[1]\n",
    "\n",
    "model.fit(x=[train_x_price, train_x_time], \n",
    "          y=train_y,\n",
    "\t      validation_data=([test_x_price, test_x_time], test_y),\n",
    "\t      epochs=25, \n",
    "          batch_size=BATCH_SIZE, \n",
    "          callbacks=callback,\n",
    "          class_weight = {0: 1,\n",
    "                          1: postive_weight})\n",
    "\n",
    "loss, accuracy = model.evaluate([test_x_price, test_x_time], \n",
    "                                test_y, \n",
    "                                batch_size=BATCH_SIZE, \n",
    "                                verbose=0)\n",
    "print(loss, accuracy)\n",
    "\n",
    "model.save('models/cnn_short6_1024_n005d.keras')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Evaluate Precision-Recall Curves"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "158/158 [==============================] - 54s 338ms/step\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x300 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = keras.models.load_model('models/cnn_short6_1024_n005d.keras')\n",
    "\n",
    "labels = model.predict([test_x_price, test_x_time])\n",
    "\n",
    "# keep probabilities for the positive outcome only\n",
    "probs = labels[:, 1]\n",
    "y_true = test_y[:, 1]\n",
    "\n",
    "# plot the precision-recall curves\n",
    "precision, recall, thresholds = precision_recall_curve(y_true, probs)\n",
    "thresholds = np.append(thresholds, np.nan)\n",
    "no_skill = y_true.sum() / len(test_y)\n",
    "\n",
    "plt.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')\n",
    "plt.plot(recall, precision, marker='.', label='CNN_short')\n",
    "plt.ylim(-0.05, 1.05)\n",
    "plt.xlabel('Recall')\n",
    "plt.ylabel('Precision')\n",
    "plt.legend()\n",
    "plt.show()\n",
    "\n",
    "plt.figure(figsize=(6.4,3))\n",
    "plt.plot([0, 1], [no_skill, no_skill], linestyle='--', label='No Skill')\n",
    "plt.plot(thresholds[:], precision[:], marker='.', label='precision')\n",
    "plt.plot(thresholds[:], recall[:], marker='.', label='recall')\n",
    "plt.xlim(0.395, 0.565)\n",
    "plt.xlabel('Threshold')\n",
    "plt.ylabel('Precision | Recall')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This shows there are no prediction thresholds where the model is able to unambigously identify the positive class.  Although given the stocastic nature of the data, this isn't surprising.\n",
    "\n",
    "The algorithm does howver show a small predictive ability, although whether its edge outweighs the market's commision rate is unknown.  It should also be noted that 1-hr price charts are particularly noisy, and that longer timeframes can provide more reliable trading signals.\n",
    "\n",
    "Precision vs. recall perhaps isn't the best way of determining sucess.  For example, if a long position is taken, and the market stays flat, the outcome is neutral.  A more useful analysis would compare the confusion between long predictions and short truths, _ie_ when trading capital would be lost.  Although this means remaking the model as a multi-class, rather than binary, classifier.\n",
    "\n",
    "But - The most meaningful measure of success would be to calculate the profit/loss curves for the series of predicted trades at different prediction thresholds..."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Calculate profit/loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1.0009118977754665, 0.9962848175664774, 1.000655732188699, 0.9948289254163182, 1.000779150081753, 0.9962523086489258, 1.0007750898488559, 1.000710225087132, 0.9948874629436907, 1.0042918398762415]\n",
      "[1.0009118977754665, 1.000655732188699, 0.9948289254163182, 1.000779150081753, 1.0007750898488559, 1.000710225087132, 0.9948874629436907, 1.0042918398762415]\n",
      "[1.0009118977754665, 0.9948289254163182, 1.000779150081753, 1.000710225087132, 0.9948874629436907, 1.0042918398762415]\n",
      "[1.0009118977754665, 1.000710225087132]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\catie\\AppData\\Local\\Temp\\ipykernel_17296\\1166755054.py:13: RuntimeWarning: divide by zero encountered in scalar divide\n",
      "  return round(wins / losses, 3)\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "def profit_factor(pl_list):\n",
    "    wins = 0.0\n",
    "    losses = 0.0\n",
    "    print(pl_list)\n",
    "    for result in pl_list:\n",
    "        if result > 1:\n",
    "            wins += (result - 1) \n",
    "        else:\n",
    "            losses += (1 - result) \n",
    "\n",
    "    return round(wins / losses, 3)\n",
    "\n",
    "\n",
    "assert len(labels) == len(test_outcomes)\n",
    "\n",
    "THRESHOLDS = [0.545, 0.546, 0.548, 0.549]\n",
    "\n",
    "df2 = pd.DataFrame()\n",
    "\n",
    "for threshold in THRESHOLDS:\n",
    "    results = []\n",
    "    for i, label in enumerate(labels):\n",
    "        if label[1] >= threshold:\n",
    "            results.append(OUTCOMES[i])\n",
    "\n",
    "    profit_loss = np.ones(len(results)+1)\n",
    "    for i, result in enumerate(results):\n",
    "        profit_loss[i+1] = profit_loss[i] * results[i]\n",
    "\n",
    "\n",
    "    df3 = pd.DataFrame(profit_loss, columns=[f'thr={threshold} profit_factor={profit_factor(results)}'])\n",
    "    df2 = pd.concat([df2, df3], axis=1)\n",
    "\n",
    "plt.plot(df2, label=list(df2.columns.values))\n",
    "plt.xlabel('Trade')\n",
    "plt.ylabel('P&L')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Notes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5045\n",
      "[[0.5951229  0.40487716]\n",
      " [0.53520316 0.46479693]\n",
      " [0.66677636 0.33322367]\n",
      " ...\n",
      " [0.49995318 0.50004685]\n",
      " [0.46632093 0.53367907]\n",
      " [0.4918398  0.5081603 ]]\n",
      "[[1. 0.]\n",
      " [1. 0.]\n",
      " [1. 0.]\n",
      " ...\n",
      " [0. 1.]\n",
      " [1. 0.]\n",
      " [1. 0.]]\n"
     ]
    }
   ],
   "source": [
    "## add cross validation\n",
    "## pad - most recent edge is important! #\n",
    "## replace maxpooling with dilated kernel to preserve data - geoff hinton #\n",
    "## replace maxpooling with stride = 2 - 'learnable pooling, all-convolution network' #\n",
    "## batch norm on conv layers? #\n",
    "## groups = channels maintains depthwise separation.  Add same multiple of filters?\n",
    "## l2 less sensitive to small changes (noise), l1 blocks some inputs #\n",
    "## layers.DepthwiseConv1D() reduces number of parameters\n",
    "## model.train(sample_weight=) heavier recent samples\n",
    "\n",
    "print(len(labels))\n",
    "print(labels)\n",
    "print(test_y)"
   ]
  }
 ],
 "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.11.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}