From 3dc9d91e48abfdb7230457a2f28f759e2ce2c44e Mon Sep 17 00:00:00 2001 From: Oleg Sheynin Date: Sat, 15 Jun 2024 00:04:59 +0000 Subject: [PATCH] progress --- tensorflow/Dockerfile | 2 + tensorflow/docker-compose.yml | 2 +- .../notebooks/leo/LSTM_All_Crypto_01.ipynb | 1149 ++++++++++++++++- 3 files changed, 1082 insertions(+), 71 deletions(-) diff --git a/tensorflow/Dockerfile b/tensorflow/Dockerfile index 637a9c1..e0da348 100644 --- a/tensorflow/Dockerfile +++ b/tensorflow/Dockerfile @@ -17,6 +17,8 @@ RUN pip install jupyterlab RUN pip install pandas RUN pip install numpy RUN pip install plotly +RUN pip install seaborn +RUN pip install statsmodels # Install additional applications RUN apt update diff --git a/tensorflow/docker-compose.yml b/tensorflow/docker-compose.yml index 98501b1..d8037f8 100644 --- a/tensorflow/docker-compose.yml +++ b/tensorflow/docker-compose.yml @@ -11,7 +11,7 @@ services: jupyter: # user: "oleg" build: ${ROOT_DIR} - image: cvtt/jupyter_gpu_tf:v1.0.6 + image: cvtt/jupyter_gpu_tf:v1.0.7 container_name: jupyter_gpu_tf runtime: nvidia environment: diff --git a/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb b/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb index ea82c7f..c130f8e 100644 --- a/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb +++ b/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 164, + "execution_count": 230, "id": "1023f2c1-e45f-4e1c-9a1b-66f59f128196", "metadata": {}, "outputs": [ @@ -11,7 +11,7 @@ "output_type": "stream", "text": [ "Panda Version: 2.2.2\n", - "Today date is: 2024-06-13\n" + "Today date is: 2024-06-14\n" ] } ], @@ -60,6 +60,9 @@ "import collections\n", "from collections import Counter\n", "\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "\n", "# Import date class from datetime module\n", "import time\n", "import datetime\n", @@ -422,33 +425,7 @@ }, { "cell_type": "code", - "execution_count": 182, - "id": "71c8bf0d-7762-47ef-a8a1-6d57ee5c8bb7", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "sample_size: 13358\n" - ] - } - ], - "source": [ - "print ('sample_size: ', sample_size)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "0802e693-29a6-4eda-a496-9504f3008c2e", - "metadata": {}, - "outputs": [], - "source": [] - }, - { - "cell_type": "code", - "execution_count": 211, + "execution_count": 240, "id": "c3dee439-a3e8-4843-8f8b-33572b4170e9", "metadata": {}, "outputs": [ @@ -457,51 +434,50 @@ "output_type": "stream", "text": [ "sample_size: 13358\n", - "[ 1108 13291]\n", - "[[5.18272282e-01 1.68025214e-04 3.77189791e-01 1.45151777e-04\n", - " 8.31595503e-01 3.95645238e-04 6.76253699e-01 2.15301382e-04]\n", - " [5.18303634e-01 1.68025214e-04 3.77154892e-01 1.45151777e-04\n", - " 8.32082769e-01 3.95645238e-04 6.76271128e-01 2.15301382e-04]\n", - " [5.18562378e-01 1.68025214e-04 3.77397110e-01 1.45151777e-04\n", - " 8.30954599e-01 3.95645238e-04 6.76918294e-01 2.15301382e-04]\n", - " [5.18341398e-01 1.68025214e-04 3.77160454e-01 1.45151777e-04\n", - " 8.31766697e-01 3.95645238e-04 6.76294450e-01 2.15301382e-04]\n", - " [5.18497467e-01 1.68025214e-04 3.77261769e-01 1.45151777e-04\n", - " 8.31990904e-01 3.95645238e-04 6.76269889e-01 2.15301382e-04]\n", - " [5.18698229e-01 1.68025214e-04 3.77392003e-01 1.45151777e-04\n", - " 8.31954856e-01 3.95645238e-04 6.76339962e-01 2.15301382e-04]\n", - " [5.18693630e-01 1.68025214e-04 3.77533283e-01 1.45151777e-04\n", - " 8.32184637e-01 3.95645238e-04 6.76516962e-01 2.15301382e-04]\n", - " [5.18672691e-01 1.68025214e-04 3.77517862e-01 1.45151777e-04\n", - " 8.32276407e-01 3.95645238e-04 6.76558233e-01 2.15301382e-04]\n", - " [4.99269291e-01 5.45867382e-04 3.68653612e-01 1.43205019e-04\n", - " 7.99339573e-01 3.86775482e-04 6.92654223e-01 3.72953569e-04]\n", - " [4.99424699e-01 5.45867382e-04 3.68590151e-01 1.43205019e-04\n", - " 7.99839862e-01 3.86775482e-04 6.92737055e-01 3.72953569e-04]\n", - " [4.99437041e-01 5.45867382e-04 3.68505112e-01 1.43205019e-04\n", - " 7.99388893e-01 3.86775482e-04 6.92646980e-01 3.72953569e-04]\n", - " [4.99561765e-01 5.45867382e-04 3.68547552e-01 1.43205019e-04\n", - " 7.99601900e-01 3.86775482e-04 6.92723486e-01 3.72953569e-04]\n", - " [4.99664819e-01 5.45867382e-04 3.68704191e-01 1.43205019e-04\n", - " 7.99877210e-01 3.86775482e-04 6.92928189e-01 3.72953569e-04]\n", - " [4.99833312e-01 5.45867382e-04 3.68823620e-01 1.43205019e-04\n", - " 7.99375187e-01 3.86775482e-04 6.93065604e-01 3.72953569e-04]\n", - " [4.99855255e-01 5.45867382e-04 3.68840191e-01 1.43205019e-04\n", - " 7.99747347e-01 3.86775482e-04 6.93183729e-01 3.72953569e-04]\n", - " [4.98030589e-01 5.45867382e-04 3.68931667e-01 1.43205019e-04\n", - " 7.98594073e-01 3.86775482e-04 6.91868385e-01 3.72953569e-04]]\n", + "[1108]\n", + "[[5.18409007e-01 1.74656457e-04 3.76978106e-01 1.87974873e-04\n", + " 8.30976720e-01 4.13691462e-04 6.76322893e-01 1.69435655e-04]\n", + " [5.18281600e-01 1.74656457e-04 3.76891560e-01 1.87974873e-04\n", + " 8.30856335e-01 4.13691462e-04 6.76295204e-01 1.69435655e-04]\n", + " [5.18160992e-01 1.74656457e-04 3.76894853e-01 1.87974873e-04\n", + " 8.31396694e-01 4.13691462e-04 6.76243830e-01 1.69435655e-04]\n", + " [5.18395710e-01 1.74656457e-04 3.77093334e-01 1.87974873e-04\n", + " 8.31512839e-01 4.13691462e-04 6.76356022e-01 1.69435655e-04]\n", + " [5.18466873e-01 1.74656457e-04 3.77115186e-01 1.87974873e-04\n", + " 8.31656507e-01 4.13691462e-04 6.76334315e-01 1.69435655e-04]\n", + " [5.18169063e-01 1.74656457e-04 3.77119085e-01 1.87974873e-04\n", + " 8.31606805e-01 4.13691462e-04 6.76275342e-01 1.69435655e-04]\n", + " [5.18300186e-01 1.74656457e-04 3.77137593e-01 1.87974873e-04\n", + " 8.31608277e-01 4.13691462e-04 6.76244964e-01 1.69435655e-04]\n", + " [5.18213605e-01 1.74656457e-04 3.77114097e-01 1.87974873e-04\n", + " 8.31657508e-01 4.13691462e-04 6.76252500e-01 1.69435655e-04]\n", + " [5.18272282e-01 1.74656457e-04 3.77189791e-01 1.87974873e-04\n", + " 8.31595503e-01 4.13691462e-04 6.76253699e-01 1.69435655e-04]\n", + " [5.18303634e-01 1.74656457e-04 3.77154892e-01 1.87974873e-04\n", + " 8.32082769e-01 4.13691462e-04 6.76271128e-01 1.69435655e-04]\n", + " [5.18562378e-01 1.74656457e-04 3.77397110e-01 1.87974873e-04\n", + " 8.30954599e-01 4.13691462e-04 6.76918294e-01 1.69435655e-04]\n", + " [5.18341398e-01 1.74656457e-04 3.77160454e-01 1.87974873e-04\n", + " 8.31766697e-01 4.13691462e-04 6.76294450e-01 1.69435655e-04]\n", + " [5.18497467e-01 1.74656457e-04 3.77261769e-01 1.87974873e-04\n", + " 8.31990904e-01 4.13691462e-04 6.76269889e-01 1.69435655e-04]\n", + " [5.18698229e-01 1.74656457e-04 3.77392003e-01 1.87974873e-04\n", + " 8.31954856e-01 4.13691462e-04 6.76339962e-01 1.69435655e-04]\n", + " [5.18693630e-01 1.74656457e-04 3.77533283e-01 1.87974873e-04\n", + " 8.32184637e-01 4.13691462e-04 6.76516962e-01 1.69435655e-04]\n", + " [5.18672691e-01 1.74656457e-04 3.77517862e-01 1.87974873e-04\n", + " 8.32276407e-01 4.13691462e-04 6.76558233e-01 1.69435655e-04]]\n", "XXXX ====== Actual Input ====== XXXX\n", - "(2, 8, 8)\n", - "[[0.51863729 0.37762073 0.83232141 0.6765906 ]\n", - " [0.49999486 0.36888691 0.79994226 0.69325938]]\n", - "(2, 1, 1)\n" + "(1, 16, 8)\n", + "[[0.51863729 0.37762073 0.83232141 0.6765906 ]]\n", + "(1, 1, 1)\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_28/500398063.py:15: SettingWithCopyWarning: \n", + "/tmp/ipykernel_28/3826110232.py:15: SettingWithCopyWarning: \n", "A value is trying to be set on a copy of a slice from a DataFrame.\n", "Try using .loc[row_indexer,col_indexer] = value instead\n", "\n", @@ -511,13 +487,13 @@ } ], "source": [ - "# 05.17.2024\n", + "# 06.14.2024\n", "# ============================\n", "sample_size = sample_test.shape[0]\n", "print ('sample_size: ', sample_size)\n", "\n", - "sl = 8 # <--- sequence length\n", - "batch = 2 # <--- batch size\n", + "sl = 16 # <--- sequence length\n", + "batch = 1 # <--- batch size\n", "n_features = 8 # <---- no. of variables\n", "n_out = 1 # <----- no. of predicted variables\n", "frwd = 1 # <--- how many to predict\n", @@ -654,8 +630,1041 @@ { "cell_type": "code", "execution_count": null, + "id": "c433b265-d167-4612-b26c-d7dad02c7021", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 253, "id": "88e292cc-1244-462a-b311-3e964773c742", "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'values' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[253], line 9\u001b[0m\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(batch\u001b[38;5;241m-\u001b[39mcnt_thrown_idx):\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Plot the autocorrelation function (ACF) \u001b[39;00m\n\u001b[1;32m 8\u001b[0m plt\u001b[38;5;241m.\u001b[39mfigure(figsize \u001b[38;5;241m=\u001b[39m (\u001b[38;5;241m12\u001b[39m, \u001b[38;5;241m6\u001b[39m))\n\u001b[0;32m----> 9\u001b[0m plot_acf(\u001b[43mvalues\u001b[49m[i], lags \u001b[38;5;241m=\u001b[39m sl \u001b[38;5;241m-\u001b[39m \u001b[38;5;241m1\u001b[39m)\n\u001b[1;32m 10\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mAutocorrelation Function (ACF)\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 11\u001b[0m plt\u001b[38;5;241m.\u001b[39mshow()\n", + "\u001b[0;31mNameError\u001b[0m: name 'values' is not defined" + ] + }, + { + "data": { + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Figure AutoCorrelations and Partial AutoCorrelations\n", + "import seaborn as sns\n", + "from statsmodels.graphics.tsaplots import plot_acf, plot_pacf\n", + "# from sklearn.preprocessing import MinMaxScaler\n", + "\n", + "for i in range(batch-cnt_thrown_idx):\n", + "# Plot the autocorrelation function (ACF) \n", + " plt.figure(figsize = (12, 6))\n", + " plot_acf(values[i], lags = sl - 1)\n", + " plt.title('Autocorrelation Function (ACF)')\n", + " plt.show()\n", + " \n", + "# Plot the partial autocorrelation function (PACF)\n", + " # plt.figure(figsize = (12, 6))\n", + " # plot_pacf(values[round(i/2)], lags = 60)\n", + " # plt.title('Partial Autocorrelation Function (PACF)')\n", + " # plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 242, + "id": "4c6cf92b-58fd-4642-81ee-d7af73c3e75f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "===================================================\n", + "sequence length: 16\n", + "batch size: 1\n", + "no. of variables: 8\n", + "no. of predicted variables: 1\n", + "how many steps forward to predict: 1\n", + "===================================================\n" + ] + } + ], + "source": [ + "print (\"===================================================\")\n", + "print (\"sequence length: \", sl)\n", + "print (\"batch size: \", batch-cnt_thrown_idx)\n", + "print (\"no. of variables: \", n_features)\n", + "print (\"no. of predicted variables: \", n_out)\n", + "print (\"how many steps forward to predict: \", frwd)\n", + "print (\"===================================================\")" + ] + }, + { + "cell_type": "code", + "execution_count": 248, + "id": "4021e394-635b-4493-8a89-a658e1229325", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
Model: \"sequential_5\"\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1mModel: \"sequential_5\"\u001b[0m\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n",
+       "┃ Layer (type)                    ┃ Output Shape           ┃       Param # ┃\n",
+       "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n",
+       "│ lstm_8 (LSTM)                   │ (None, 512)            │     1,067,008 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ repeat_vector_4 (RepeatVector)  │ (None, 1, 512)         │             0 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ lstm_9 (LSTM)                   │ (None, 1, 1024)        │     6,295,552 │\n",
+       "├─────────────────────────────────┼────────────────────────┼───────────────┤\n",
+       "│ time_distributed_4              │ (None, 1, 1)           │         1,025 │\n",
+       "│ (TimeDistributed)               │                        │               │\n",
+       "└─────────────────────────────────┴────────────────────────┴───────────────┘\n",
+       "
\n" + ], + "text/plain": [ + "┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━━━━┓\n", + "┃\u001b[1m \u001b[0m\u001b[1mLayer (type) \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1mOutput Shape \u001b[0m\u001b[1m \u001b[0m┃\u001b[1m \u001b[0m\u001b[1m Param #\u001b[0m\u001b[1m \u001b[0m┃\n", + "┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━━━━┩\n", + "│ lstm_8 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m1,067,008\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ repeat_vector_4 (\u001b[38;5;33mRepeatVector\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m512\u001b[0m) │ \u001b[38;5;34m0\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ lstm_9 (\u001b[38;5;33mLSTM\u001b[0m) │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1024\u001b[0m) │ \u001b[38;5;34m6,295,552\u001b[0m │\n", + "├─────────────────────────────────┼────────────────────────┼───────────────┤\n", + "│ time_distributed_4 │ (\u001b[38;5;45mNone\u001b[0m, \u001b[38;5;34m1\u001b[0m, \u001b[38;5;34m1\u001b[0m) │ \u001b[38;5;34m1,025\u001b[0m │\n", + "│ (\u001b[38;5;33mTimeDistributed\u001b[0m) │ │ │\n", + "└─────────────────────────────────┴────────────────────────┴───────────────┘\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Total params: 7,363,585 (28.09 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Total params: \u001b[0m\u001b[38;5;34m7,363,585\u001b[0m (28.09 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Trainable params: 7,363,585 (28.09 MB)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Trainable params: \u001b[0m\u001b[38;5;34m7,363,585\u001b[0m (28.09 MB)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
 Non-trainable params: 0 (0.00 B)\n",
+       "
\n" + ], + "text/plain": [ + "\u001b[1m Non-trainable params: \u001b[0m\u001b[38;5;34m0\u001b[0m (0.00 B)\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/50\n", + "1/1 - 2s - 2s/step - loss: 0.4657\n", + "Epoch 2/50\n", + "1/1 - 0s - 27ms/step - loss: 0.2649\n", + "Epoch 3/50\n", + "1/1 - 0s - 26ms/step - loss: 0.1508\n", + "Epoch 4/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0857\n", + "Epoch 5/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0486\n", + "Epoch 6/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0275\n", + "Epoch 7/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0155\n", + "Epoch 8/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0087\n", + "Epoch 9/50\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.11/dist-packages/keras/src/callbacks/early_stopping.py:156: UserWarning: Early stopping conditioned on metric `val_loss` which is not available. Available metrics are: loss\n", + " current = self.get_monitor_value(logs)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1/1 - 0s - 26ms/step - loss: 0.0049\n", + "Epoch 10/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0028\n", + "Epoch 11/50\n", + "1/1 - 0s - 26ms/step - loss: 0.0015\n", + "Epoch 12/50\n", + "1/1 - 0s - 26ms/step - loss: 8.6631e-04\n", + "Epoch 13/50\n", + "1/1 - 0s - 26ms/step - loss: 4.8503e-04\n", + "Epoch 14/50\n", + "1/1 - 0s - 26ms/step - loss: 2.7142e-04\n", + "Epoch 15/50\n", + "1/1 - 0s - 26ms/step - loss: 1.5183e-04\n", + "Epoch 16/50\n", + "1/1 - 0s - 26ms/step - loss: 8.4915e-05\n", + "Epoch 17/50\n", + "1/1 - 0s - 26ms/step - loss: 4.7482e-05\n", + "Epoch 18/50\n", + "1/1 - 0s - 26ms/step - loss: 2.6546e-05\n", + "Epoch 19/50\n", + "1/1 - 0s - 26ms/step - loss: 1.4839e-05\n", + "Epoch 20/50\n", + "1/1 - 0s - 26ms/step - loss: 8.2946e-06\n", + "Epoch 21/50\n", + "1/1 - 0s - 26ms/step - loss: 4.6361e-06\n", + "Epoch 22/50\n", + "1/1 - 0s - 26ms/step - loss: 2.5911e-06\n", + "Epoch 23/50\n", + "1/1 - 0s - 26ms/step - loss: 1.4481e-06\n", + "Epoch 24/50\n", + "1/1 - 0s - 26ms/step - loss: 8.0920e-07\n", + "Epoch 25/50\n", + "1/1 - 0s - 26ms/step - loss: 4.5228e-07\n", + "Epoch 26/50\n", + "1/1 - 0s - 26ms/step - loss: 2.5271e-07\n", + "Epoch 27/50\n", + "1/1 - 0s - 26ms/step - loss: 1.4123e-07\n", + "Epoch 28/50\n", + "1/1 - 0s - 26ms/step - loss: 7.8914e-08\n", + "Epoch 29/50\n", + "1/1 - 0s - 26ms/step - loss: 4.4095e-08\n", + "Epoch 30/50\n", + "1/1 - 0s - 26ms/step - loss: 2.4630e-08\n", + "Epoch 31/50\n", + "1/1 - 0s - 26ms/step - loss: 1.3760e-08\n", + "Epoch 32/50\n", + "1/1 - 0s - 26ms/step - loss: 7.6875e-09\n", + "Epoch 33/50\n", + "1/1 - 0s - 26ms/step - loss: 4.2910e-09\n", + "Epoch 34/50\n", + "1/1 - 0s - 26ms/step - loss: 2.4005e-09\n", + "Epoch 35/50\n", + "1/1 - 0s - 26ms/step - loss: 1.3437e-09\n", + "Epoch 36/50\n", + "1/1 - 0s - 26ms/step - loss: 7.4849e-10\n", + "Epoch 37/50\n", + "1/1 - 0s - 26ms/step - loss: 4.1797e-10\n", + "Epoch 38/50\n", + "1/1 - 0s - 26ms/step - loss: 2.3283e-10\n", + "Epoch 39/50\n", + "1/1 - 0s - 26ms/step - loss: 1.3097e-10\n", + "Epoch 40/50\n", + "1/1 - 0s - 26ms/step - loss: 7.3669e-11\n", + "Epoch 41/50\n", + "1/1 - 0s - 26ms/step - loss: 4.1439e-11\n", + "Epoch 42/50\n", + "1/1 - 0s - 26ms/step - loss: 2.2737e-11\n", + "Epoch 43/50\n", + "1/1 - 0s - 26ms/step - loss: 1.2790e-11\n", + "Epoch 44/50\n", + "1/1 - 0s - 26ms/step - loss: 7.5175e-12\n", + "Epoch 45/50\n", + "1/1 - 0s - 26ms/step - loss: 4.3521e-12\n", + "Epoch 46/50\n", + "1/1 - 0s - 26ms/step - loss: 2.4016e-12\n", + "Epoch 47/50\n", + "1/1 - 0s - 26ms/step - loss: 1.4211e-12\n", + "Epoch 48/50\n", + "1/1 - 0s - 26ms/step - loss: 7.9936e-13\n", + "Epoch 49/50\n", + "1/1 - 0s - 26ms/step - loss: 5.1159e-13\n", + "Epoch 50/50\n", + "1/1 - 0s - 26ms/step - loss: 2.8777e-13\n" + ] + } + ], + "source": [ + "# from keras.initializers import glorot_uniform, he_uniform, orthogonal, zeros\n", + "\n", + "n_steps = sl\n", + "\n", + "model_8f = Sequential()\n", + "model_8f.add(tf.keras.layers.Input(shape = (n_steps, n_features)))\n", + "# model_8f.add(tf.keras.layers.LSTM(units = 512, activation = 'relu', return_sequences = False)) \n", + "\n", + "\n", + "model_8f.add(tf.keras.layers.LSTM(\n", + " units = 512,\n", + " # kernel_initializer = glorot_uniform(), # Initialize the input weights\n", + " # recurrent_initializer = orthogonal(), # Initialize the recurrent weights\n", + " # bias_initializer = zeros(), # Initialize the biases\n", + " activation = 'relu', \n", + " return_sequences = False\n", + "))\n", + "\n", + "# model_8f.add(tf.keras.layers.Dropout(0.2)) \n", + "model_8f.add(tf.keras.layers.RepeatVector(frwd))\n", + "model_8f.add(tf.keras.layers.LSTM(units = 1024, activation = 'linear', return_sequences = True))\n", + "# model_8f.add(tf.keras.layers.Dropout(0.2)) \n", + "model_8f.add(tf.keras.layers.TimeDistributed(Dense(units = n_out)))\n", + "\n", + "# Compile the model with MSE loss computed for each time step\n", + "\n", + "sgd = SGD(learning_rate = 0.1)\n", + "model_8f.compile(optimizer = sgd, loss = 'mean_squared_error')\n", + "# model_8f.compile(optimizer = 'adam', loss = 'mean_squared_error')\n", + "model_8f.summary()\n", + "\n", + "# Define a custom callback to log errors at each time step\n", + "# class TimeStepErrorLogger(tf.keras.callbacks.Callback):\n", + "# def on_epoch_end(self, epoch, logs = None):\n", + "# predictions = self.model.predict(X)\n", + "# errors = (predictions - y) ** 2 # Squared errors\n", + "# time_step_errors = np.mean(errors, axis = 0) # Mean error for each time step\n", + "# print(f\"Epoch {epoch + 1} - Time Step Errors: {time_step_errors}\") \n", + "\n", + "\n", + "es = EarlyStopping(monitor = 'val_loss', mode = 'min', verbose = 1, patience = 5)\n", + "\n", + "# fit model\n", + "# The number of epochs is the number of complete passes through the training dataset\n", + "history = model_8f.fit(X, y, epochs = 50, \n", + " # validation_split = 0.2,\n", + " verbose = 2, callbacks=[es])\n", + " # , callbacks = [TimeStepErrorLogger()])" + ] + }, + { + "cell_type": "code", + "execution_count": 249, + "id": "badacf02-562c-495a-8d62-374545da5804", + "metadata": {}, + "outputs": [ + { + "ename": "KeyError", + "evalue": "'val_loss'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[249], line 6\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Plot the data\u001b[39;00m\n\u001b[1;32m 5\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(history\u001b[38;5;241m.\u001b[39mhistory[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mloss\u001b[39m\u001b[38;5;124m'\u001b[39m], \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mblue\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m----> 6\u001b[0m ax\u001b[38;5;241m.\u001b[39mplot(\u001b[43mhistory\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhistory\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mval_loss\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mred\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 8\u001b[0m \u001b[38;5;66;03m# Customize the plot\u001b[39;00m\n\u001b[1;32m 9\u001b[0m ax\u001b[38;5;241m.\u001b[39mset_title(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mModel Loss (blue) vs Val. Loss (red)\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", + "\u001b[0;31mKeyError\u001b[0m: 'val_loss'" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(1, 1)\n", + "\n", + "# Plot the data\n", + "ax.plot(history.history['loss'], 'blue')\n", + "ax.plot(history.history['val_loss'], 'red')\n", + "\n", + "# Customize the plot\n", + "ax.set_title('Model Loss (blue) vs Val. Loss (red)')\n", + "ax.set_xlabel('Epoch')\n", + "ax.set_ylabel('Loss')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 221, + "id": "d08d10b3-a984-4dec-b1af-e29a9e937626", + "metadata": {}, + "outputs": [], + "source": [ + "# Extract weights from the LSTM layer\n", + "lstm_layer = model_8f.layers[0]\n", + "lstm_weights = lstm_layer.get_weights()" + ] + }, + { + "cell_type": "code", + "execution_count": 222, + "id": "1f7cdb81-3ea1-467d-8492-fbdc469a4039", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel shape: (8, 2048)\n", + "Recurrent Kernel shape: (512, 2048)\n", + "Bias shape: (2048,)\n" + ] + } + ], + "source": [ + "kernel, recurrent_kernel, bias = lstm_weights\n", + "\n", + "# Print the shapes\n", + "print(f\"Kernel shape: {kernel.shape}\")\n", + "print(f\"Recurrent Kernel shape: {recurrent_kernel.shape}\")\n", + "print(f\"Bias shape: {bias.shape}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 223, + "id": "5be4cb34-6a95-426f-b08f-1c26fcfdaa90", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Kernel weights: [[ 0.05232579 0.01374082 0.01113737 ... -0.03336089 0.03715584\n", + " -0.03538815]\n", + " [ 0.03264289 0.02306121 0.02604442 ... 0.03129478 -0.05207984\n", + " 0.04096095]\n", + " [-0.02632057 -0.02589257 -0.02369264 ... -0.03858705 -0.01252202\n", + " 0.00666459]\n", + " ...\n", + " [-0.01920575 -0.00956063 0.02410255 ... 0.01255936 0.04612235\n", + " 0.05381919]\n", + " [ 0.04781022 0.01975601 -0.0432153 ... 0.05187599 -0.01336266\n", + " 0.03635232]\n", + " [-0.03965205 -0.00055679 -0.03181865 ... 0.0390408 -0.0238521\n", + " 0.00138673]]\n", + "Recurrent kernel weights: [[-0.01153879 -0.00017272 0.0282393 ... 0.00996209 0.01181875\n", + " -0.01943585]\n", + " [ 0.01909763 0.00872338 0.02296009 ... 0.01635076 0.01008803\n", + " -0.01466706]\n", + " [ 0.02507331 0.0413265 -0.00896156 ... 0.01102871 0.00432566\n", + " 0.01624689]\n", + " ...\n", + " [-0.00220611 -0.00429316 0.03294532 ... -0.02962208 0.02178407\n", + " -0.00670702]\n", + " [ 0.00095747 0.00812461 0.00659628 ... 0.03368684 -0.05981153\n", + " 0.00807448]\n", + " [ 0.00640679 0.01504548 0.01278104 ... -0.00735644 -0.00102678\n", + " -0.02216036]]\n", + "Bias weights: [ 8.6383414e-05 0.0000000e+00 0.0000000e+00 ... -6.8583427e-07\n", + " 1.6081285e-05 1.9838195e-04]\n" + ] + } + ], + "source": [ + "# Print the weights\n", + "print(\"Kernel weights:\", kernel)\n", + "print(\"Recurrent kernel weights:\", recurrent_kernel)\n", + "print(\"Bias weights:\", bias)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cb2a2814-070a-40e4-b909-a18698b0b848", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 250, + "id": "7ab3f50a-cf41-4307-b34b-17b0614504e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "sample_size: 3340\n", + "[2459 1981]\n", + "[[4.93597160e-01 1.88567599e-04 3.68336025e-01 9.40572538e-05\n", + " 7.99405968e-01 3.40939455e-04 6.92646161e-01 8.27791498e-05]\n", + " [4.93609641e-01 1.88567599e-04 3.68221016e-01 9.40572538e-05\n", + " 7.98633495e-01 3.40939455e-04 6.92502338e-01 8.27791498e-05]\n", + " [4.93462410e-01 1.88567599e-04 3.68192285e-01 9.40572538e-05\n", + " 7.98732066e-01 3.40939455e-04 6.92478336e-01 8.27791498e-05]\n", + " [4.93224118e-01 1.88567599e-04 3.68046015e-01 9.40572538e-05\n", + " 7.98648803e-01 3.40939455e-04 6.92426662e-01 8.27791498e-05]\n", + " [4.93080436e-01 1.88567599e-04 3.67989744e-01 9.40572538e-05\n", + " 7.98699921e-01 3.40939455e-04 6.92436495e-01 8.27791498e-05]\n", + " [4.93280821e-01 1.88567599e-04 3.68143955e-01 9.40572538e-05\n", + " 7.99042488e-01 3.40939455e-04 6.92612000e-01 8.27791498e-05]\n", + " [4.93273371e-01 1.88567599e-04 3.68186350e-01 9.40572538e-05\n", + " 7.99276127e-01 3.40939455e-04 6.92707897e-01 8.27791498e-05]\n", + " [4.93912719e-01 1.88567599e-04 3.67940442e-01 9.40572538e-05\n", + " 7.99959683e-01 3.40939455e-04 6.92539084e-01 8.27791498e-05]\n", + " [4.93303158e-01 1.88567599e-04 3.68145198e-01 9.40572538e-05\n", + " 7.99226963e-01 3.40939455e-04 6.92711968e-01 8.27791498e-05]\n", + " [4.93394588e-01 1.88567599e-04 3.68085665e-01 9.40572538e-05\n", + " 7.98890779e-01 3.40939455e-04 6.92578699e-01 8.27791498e-05]\n", + " [4.93484151e-01 1.88567599e-04 3.68108715e-01 9.40572538e-05\n", + " 7.98869128e-01 3.40939455e-04 6.92501961e-01 8.27791498e-05]\n", + " [4.93506775e-01 1.88567599e-04 3.68086727e-01 9.40572538e-05\n", + " 7.98950462e-01 3.40939455e-04 6.92526095e-01 8.27791498e-05]\n", + " [4.93460716e-01 1.88567599e-04 3.68031436e-01 9.40572538e-05\n", + " 7.98795847e-01 3.40939455e-04 6.92517939e-01 8.27791498e-05]\n", + " [4.93580922e-01 1.88567599e-04 3.68036301e-01 9.40572538e-05\n", + " 7.98821485e-01 3.40939455e-04 6.92509088e-01 8.27791498e-05]\n", + " [4.93484923e-01 1.88567599e-04 3.68053843e-01 9.40572538e-05\n", + " 7.98741236e-01 3.40939455e-04 6.92521550e-01 8.27791498e-05]\n", + " [4.93562354e-01 1.88567599e-04 3.68097200e-01 9.40572538e-05\n", + " 7.98728388e-01 3.40939455e-04 6.92600633e-01 8.27791498e-05]\n", + " [4.96013375e-01 8.69266756e-05 3.69958064e-01 1.70093454e-04\n", + " 8.06885430e-01 4.65473747e-04 6.96517911e-01 2.11211773e-04]\n", + " [4.96082497e-01 8.69266756e-05 3.69958733e-01 1.70093454e-04\n", + " 8.07015134e-01 4.65473747e-04 6.96595439e-01 2.11211773e-04]\n", + " [4.96078576e-01 8.69266756e-05 3.70110112e-01 1.70093454e-04\n", + " 8.06939231e-01 4.65473747e-04 6.96860974e-01 2.11211773e-04]\n", + " [4.96055090e-01 8.69266756e-05 3.70135799e-01 1.70093454e-04\n", + " 8.06903318e-01 4.65473747e-04 6.96754418e-01 2.11211773e-04]\n", + " [4.96091402e-01 8.69266756e-05 3.70108084e-01 1.70093454e-04\n", + " 8.06979031e-01 4.65473747e-04 6.96658593e-01 2.11211773e-04]\n", + " [4.95994443e-01 8.69266756e-05 3.69934927e-01 1.70093454e-04\n", + " 8.06906337e-01 4.65473747e-04 6.96543349e-01 2.11211773e-04]\n", + " [4.95899476e-01 8.69266756e-05 3.69912433e-01 1.70093454e-04\n", + " 8.06999576e-01 4.65473747e-04 6.96474965e-01 2.11211773e-04]\n", + " [4.95920517e-01 8.69266756e-05 3.69897038e-01 1.70093454e-04\n", + " 8.06788626e-01 4.65473747e-04 6.96369088e-01 2.11211773e-04]\n", + " [4.96045006e-01 8.69266756e-05 3.69913218e-01 1.70093454e-04\n", + " 8.06884572e-01 4.65473747e-04 6.96308858e-01 2.11211773e-04]\n", + " [4.95929403e-01 8.69266756e-05 3.69922259e-01 1.70093454e-04\n", + " 8.06274165e-01 4.65473747e-04 6.96246735e-01 2.11211773e-04]\n", + " [4.95997900e-01 8.69266756e-05 3.69836113e-01 1.70093454e-04\n", + " 8.06678341e-01 4.65473747e-04 6.96386785e-01 2.11211773e-04]\n", + " [4.95930560e-01 8.69266756e-05 3.69808869e-01 1.70093454e-04\n", + " 8.06040310e-01 4.65473747e-04 6.96455563e-01 2.11211773e-04]\n", + " [4.95965278e-01 8.69266756e-05 3.69787820e-01 1.70093454e-04\n", + " 8.05964893e-01 4.65473747e-04 6.96416290e-01 2.11211773e-04]\n", + " [4.95945132e-01 8.69266756e-05 3.69639940e-01 1.70093454e-04\n", + " 8.06012342e-01 4.65473747e-04 6.96354516e-01 2.11211773e-04]\n", + " [4.95805449e-01 8.69266756e-05 3.69532449e-01 1.70093454e-04\n", + " 8.05758002e-01 4.65473747e-04 6.96019279e-01 2.11211773e-04]\n", + " [4.95804639e-01 8.69266756e-05 3.69598758e-01 1.70093454e-04\n", + " 8.05796060e-01 4.65473747e-04 6.96123180e-01 2.11211773e-04]]\n", + "XXXX ====== Actual Input ====== XXXX\n", + "(2, 16, 8)\n", + "(2, 1, 1)\n" + ] + } + ], + "source": [ + "# Validation Set - 06.14.2024\n", + "# ============================\n", + "# Reset Index\n", + "sample_valid = sample_valid.reset_index(drop = True)\n", + "sample_size = sample_valid.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "# sample_valid.head()\n", + "# sl = 8 # <--- sequence length\n", + "batch_valid = 2 # <--- batch size\n", + "# n_features = 8 # <---- no. of variables\n", + "# n_out = 1 # <----- no. of predicted variables\n", + "# frwd = 1 # <--- how many to predict\n", + "\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_valid['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_valid.index, size = batch_valid, replace = False)\n", + "\n", + "sample_valid.loc[selected_indices, 'Selected'] = 1 # print (sample_valid[sample_valid['Selected'] == 1])\n", + "chosen_idx1 = sample_valid[sample_valid['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_xrp = np.empty((1, )) # final input/output\n", + "all_ts_eth = np.empty((1, )) # final input/output\n", + "all_ts_ltc = np.empty((1, )) # final input/output\n", + "all_ts_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "aft_ts_xrp = np.empty((1))\n", + "aft_ts_eth = np.empty((1))\n", + "aft_ts_ltc = np.empty((1))\n", + "aft_ts_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_valid.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_valid.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # print ('====================')\n", + " sr_before_vwap_xrp = np.array(selected_rows_before['vwap_xrp'])\n", + " sr_after_vwap_xrp = np.array(selected_rows_after['vwap_xrp']) \n", + " # print (sr_before_vwap_xrp)\n", + "\n", + "# Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_vwap_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + "\n", + " sr_before_vwap_eth = np.array(selected_rows_before['vwap_eth'])\n", + " sr_after_vwap_eth = np.array(selected_rows_after['vwap_eth'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_vwap_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "\n", + " sr_before_vwap_ltc = np.array(selected_rows_before['vwap_ltc'])\n", + " sr_after_vwap_ltc = np.array(selected_rows_after['vwap_ltc'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_vwap_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + " \n", + " sr_before_vwap_btc = np.array(selected_rows_before['vwap_btc'])\n", + " sr_after_vwap_btc = np.array(selected_rows_after['vwap_btc'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_vwap_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + " \n", + " all_ts_xrp = np.concatenate((all_ts_xrp, sr_before_vwap_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + " \n", + " all_ts_eth = np.concatenate((all_ts_eth, sr_before_vwap_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "\n", + " all_ts_ltc = np.concatenate((all_ts_ltc, sr_before_vwap_ltc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "\n", + " all_ts_btc = np.concatenate((all_ts_btc, sr_before_vwap_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + " aft_ts_xrp = np.concatenate((aft_ts_xrp, sr_after_vwap_xrp))\n", + " aft_ts_eth = np.concatenate((aft_ts_eth, sr_after_vwap_eth))\n", + " aft_ts_ltc = np.concatenate((aft_ts_ltc, sr_after_vwap_ltc))\n", + " aft_ts_btc = np.concatenate((aft_ts_btc, sr_after_vwap_btc))\n", + "\n", + "X_XRP = all_ts_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "X_ETH = all_ts_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC = all_ts_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC = all_ts_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0_valid = np.column_stack((X_XRP, X_XRP_stdev, X_ETH, X_ETH_stdev, X_LTC, X_LTC_stdev, X_BTC, X_BTC_stdev))\n", + "print (X0_valid)\n", + "\n", + "# ======== Model Input =========\n", + "X_valid = X0_valid.reshape(batch_valid-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X_valid.shape)\n", + "\n", + "y_XRP = aft_ts_xrp[1:]\n", + "y_ETH = aft_ts_eth[1:]\n", + "y_LTC = aft_ts_ltc[1:]\n", + "y_BTC = aft_ts_btc[1:]\n", + "\n", + "# y_valid = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "# print (y_valid)\n", + "\n", + "y_valid = y_BTC.reshape(batch_valid-cnt_thrown_idx, frwd, n_out)\n", + "# print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y_valid.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 251, + "id": "263e1cab-3b94-49e2-a278-fa0336867310", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[1m1/1\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 666ms/step\n", + "y_valid\n", + "\n", + "(2, 1, 1)\n", + "[[[0.69274031]]\n", + "\n", + " [[0.69615353]]]\n", + "y_hat\n", + "\n", + "(2, 1)\n", + "[[0.6757623]\n", + " [0.6760601]]\n" + ] + } + ], + "source": [ + "y_hat = model_8f.predict(X_valid, verbose = 1).reshape(batch_valid-cnt_thrown_idx, frwd)\n", + "# print (sl)\n", + "\n", + "print ('y_valid')\n", + "print (type(y_valid))\n", + "print (y_valid.shape)\n", + "print (y_valid)\n", + "# print (y_valid[0:10])\n", + "\n", + "print ('y_hat')\n", + "print (type(y_hat))\n", + "print (y_hat.shape)\n", + "print (y_hat)\n", + "# y_ht1 = y_hat.reshape(batch-cnt_thrown_idx, frwd)\n", + "# # print (y_hat[0:10])\n", + "# print (y_ht1)" + ] + }, + { + "cell_type": "code", + "execution_count": 252, + "id": "e1969a05-91ff-40df-a466-01edd42f1b40", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "0\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "1\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(batch_valid-cnt_thrown_idx):\n", + " print ('\\n') \n", + " print (i)\n", + " X_resh = X_valid[i:i+1, :, 6].flatten()\n", + " # print (X_resh)\n", + " # print ('\\n')\n", + " y_resh = y_valid[i:i+1].flatten()\n", + " # print (y_resh)\n", + " y_est_resh = y_hat[i:i+1].flatten()\n", + " # print (y_est_resh)\n", + " # print ('\\n')\n", + " actual = np.concatenate((X_resh, y_resh)) * 100000.00\n", + " # print (actual)\n", + " # print ('\\n')\n", + " estimate = np.concatenate((X_resh, y_est_resh)) * 100000.00\n", + " # print (estimate)\n", + "\n", + " dates = list(range(sl+frwd))\n", + " \n", + " # Create a pandas DataFrame\n", + " data = pd.DataFrame({'Date': dates, 'Actuals': actual, 'Forecasts': estimate})\n", + " \n", + " # Set the 'Date' column as the index\n", + " data.set_index('Date', inplace=True)\n", + " \n", + " # Create a figure and axis object using object-oriented style\n", + " fig, ax = plt.subplots(figsize = (10, 6))\n", + " \n", + " # Plot actuals vs. forecasts\n", + " ax.plot(data.index, data['Forecasts'], label = 'Forecasts', marker = 'x')\n", + " ax.plot(data.index, data['Actuals'], label = 'Actuals', marker = 'o')\n", + " \n", + " # Set labels and title\n", + " ax.set_xlabel('Date')\n", + " ax.set_ylabel('Value')\n", + " ax.set_title('Actuals vs. Forecasts')\n", + "\n", + " ax.legend() # Add legend\n", + "\n", + " ax.grid(True) # Add grid\n", + " \n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4acc8461-7c33-4b38-91c7-422f89d7d5b0", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "75c0ee52-c740-434a-92bd-4f46f9ce290a", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 255, + "id": "7a9e8c46-d24e-4ce9-b20a-232b4a86dab6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date close_xrp volume_xrp vwap_xrp close_eth volume_eth vwap_eth \\\n", + "0 1-0-0 0.5173 28809.165339 0.517217 0.376204 37.497964 0.376108 \n", + "\n", + " close_ltc volume_ltc vwap_ltc close_btc volume_btc vwap_btc Selected \n", + "0 0.8317 110.056253 0.831662 0.67506 2.045049 0.674969 0 \n" + ] + } + ], + "source": [ + "print (sample_test.head(1))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "39259ac7-422b-48dc-aecd-2c9799ae3066", + "metadata": {}, + "outputs": [], + "source": [ + "# variables are close and volume\n", + "# ==============================\n", + "# Test Sample --- 06.14.2024\n", + "# ==============================\n", + "sample_size = sample_test.shape[0]\n", + "print ('sample_size: ', sample_size)\n", + "\n", + "sl = 16 # <--- sequence length\n", + "batch = 1 # <--- batch size\n", + "n_features = 8 # <---- no. of variables\n", + "n_out = 1 # <----- no. of predicted variables\n", + "frwd = 1 # <--- how many to predict\n", + "\n", + "\n", + "# Trimming Indices !!!\n", + "# Marking selected rows\n", + "sample_test['Selected'] = 0\n", + "\n", + "# Selecting m random rows without replacement\n", + "np.random.seed(125)\n", + "selected_indices = np.random.choice(sample_test.index, size = batch, replace = False)\n", + "\n", + "sample_test.loc[selected_indices, 'Selected'] = 1 # print (sample_test[sample_test['Selected'] == 1])\n", + "chosen_idx1 = sample_test[sample_test['Selected'] == 1].index\n", + "chosen_idx2 = chosen_idx1[chosen_idx1 > sl]\n", + "\n", + "thrown_idx1 = chosen_idx1[chosen_idx1 <= sl]\n", + "cnt_thrown_idx1 = len(thrown_idx1)\n", + "\n", + "chosen_idx3 = chosen_idx2[chosen_idx2 < (sample_size - frwd)]\n", + "\n", + "thrown_idx2 = chosen_idx2[chosen_idx2 >= (sample_size - frwd)]\n", + "cnt_thrown_idx2 = len(thrown_idx2)\n", + "\n", + "cnt_thrown_idx = cnt_thrown_idx1 + cnt_thrown_idx2\n", + "\n", + "print (selected_indices)\n", + "\n", + "all_ts_xrp = np.empty((1, )) # final input/output\n", + "all_ts_eth = np.empty((1, )) # final input/output\n", + "all_ts_ltc = np.empty((1, )) # final input/output\n", + "all_ts_btc = np.empty((1, )) # final input/output\n", + "\n", + "stdev_xrp = np.empty((1, )) # final input/output\n", + "stdev_eth = np.empty((1, )) # final input/output\n", + "stdev_ltc = np.empty((1, )) # final input/output\n", + "stdev_btc = np.empty((1, )) # final input/output\n", + "\n", + "aft_ts_xrp = np.empty((1))\n", + "aft_ts_eth = np.empty((1))\n", + "aft_ts_ltc = np.empty((1))\n", + "aft_ts_btc = np.empty((1))\n", + "\n", + "for idx in chosen_idx3:\n", + " selected_rows_before = sample_test.iloc[max(0, idx-sl): idx]\n", + " selected_rows_after = sample_test.iloc[max(0, idx): idx+frwd]\n", + "\n", + " # print ('====================')\n", + " sr_before_vwap_xrp = np.array(selected_rows_before['vwap_xrp'])\n", + " sr_after_vwap_xrp = np.array(selected_rows_after['vwap_xrp']) \n", + " # print (sr_before_vwap_xrp)\n", + "\n", + "# Compute standard deviation\n", + " std_dev_xrp = np.std(sr_before_vwap_xrp)\n", + " std_dev_xrp_arr = np.repeat(std_dev_xrp, sl)\n", + " # print(std_dev_xrp_arr)\n", + "\n", + " sr_before_vwap_eth = np.array(selected_rows_before['vwap_eth'])\n", + " sr_after_vwap_eth = np.array(selected_rows_after['vwap_eth'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_eth = np.std(sr_before_vwap_eth)\n", + " std_dev_eth_arr = np.repeat(std_dev_eth, sl)\n", + " # print(std_dev_eth_arr)\n", + " \n", + "\n", + " sr_before_vwap_ltc = np.array(selected_rows_before['vwap_ltc'])\n", + " sr_after_vwap_ltc = np.array(selected_rows_after['vwap_ltc'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_ltc = np.std(sr_before_vwap_ltc)\n", + " std_dev_ltc_arr = np.repeat(std_dev_ltc, sl)\n", + " # print(std_dev_ltc_arr)\n", + " \n", + " sr_before_vwap_btc = np.array(selected_rows_before['vwap_btc'])\n", + " sr_after_vwap_btc = np.array(selected_rows_after['vwap_btc'])\n", + "\n", + "# Compute standard deviation\n", + " std_dev_btc = np.std(sr_before_vwap_btc)\n", + " std_dev_btc_arr = np.repeat(std_dev_btc, sl)\n", + " # print(std_dev_btc_arr)\n", + " \n", + " all_ts_xrp = np.concatenate((all_ts_xrp, sr_before_vwap_xrp))\n", + " stdev_xrp = np.concatenate((stdev_xrp, std_dev_xrp_arr))\n", + " \n", + " all_ts_eth = np.concatenate((all_ts_eth, sr_before_vwap_eth))\n", + " stdev_eth = np.concatenate((stdev_eth, std_dev_eth_arr))\n", + "\n", + " all_ts_ltc = np.concatenate((all_ts_ltc, sr_before_vwap_ltc))\n", + " stdev_ltc = np.concatenate((stdev_ltc, std_dev_ltc_arr))\n", + "\n", + " all_ts_btc = np.concatenate((all_ts_btc, sr_before_vwap_btc))\n", + " stdev_btc = np.concatenate((stdev_btc, std_dev_btc_arr))\n", + "\n", + " aft_ts_xrp = np.concatenate((aft_ts_xrp, sr_after_vwap_xrp))\n", + " aft_ts_eth = np.concatenate((aft_ts_eth, sr_after_vwap_eth))\n", + " aft_ts_ltc = np.concatenate((aft_ts_ltc, sr_after_vwap_ltc))\n", + " aft_ts_btc = np.concatenate((aft_ts_btc, sr_after_vwap_btc))\n", + "\n", + "X_XRP = all_ts_xrp[1:]\n", + "X_XRP_stdev = stdev_xrp[1:]\n", + "\n", + "X_ETH = all_ts_eth[1:]\n", + "X_ETH_stdev = stdev_eth[1:]\n", + "\n", + "X_LTC = all_ts_ltc[1:]\n", + "X_LTC_stdev = stdev_ltc[1:]\n", + "\n", + "X_BTC = all_ts_btc[1:]\n", + "X_BTC_stdev = stdev_btc[1:]\n", + "\n", + "X0 = np.column_stack((X_XRP, X_XRP_stdev, X_ETH, X_ETH_stdev, X_LTC, X_LTC_stdev, X_BTC, X_BTC_stdev))\n", + "print (X0)\n", + "\n", + "# ======== Model Input =========\n", + "X = X0.reshape(batch-cnt_thrown_idx, sl, n_features)\n", + "print ('XXXX ====== Actual Input ====== XXXX')\n", + "print (X.shape)\n", + "\n", + "y_XRP = aft_ts_xrp[1:]\n", + "y_ETH = aft_ts_eth[1:]\n", + "y_LTC = aft_ts_ltc[1:]\n", + "y_BTC = aft_ts_btc[1:]\n", + "\n", + "y = np.column_stack((y_XRP, y_ETH, y_LTC, y_BTC))\n", + "print (y)\n", + "\n", + "y = y_BTC.reshape(batch-cnt_thrown_idx, frwd, n_out)\n", + "# print ('YYYY ====== Actual Input ====== YYYY')\n", + "print (y.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "47d6927d-9021-4a56-9e52-ee2061bd5979", + "metadata": {}, "outputs": [], "source": [] }