From 275bdcada67017e2997c88b8ea281a75bf0823c3 Mon Sep 17 00:00:00 2001
From: Oleg Sheynin <osheynin@gmail.com>
Date: Fri, 7 Jun 2024 00:47:34 +0000
Subject: [PATCH] progress

---
 .gitignore                                    |   1 +
 pytorch/.gitignore                            |   1 +
 pytorch/docker-compose.yml                    |   4 +-
 pytorch/get_version.sh                        |  89 ++++
 pytorch/notebooks/Testing GPU.ipynb           | 138 +++---
 pytorch/notebooks/autogluon_chronos.ipynb     | 391 ++++++++++++++++
 tensorflow/notebooks/Testing GPU.ipynb        |  10 +-
 .../notebooks/leo/LSTM_All_Crypto_01.ipynb    | 443 ++++++++++++++++++
 8 files changed, 1010 insertions(+), 67 deletions(-)
 create mode 100644 pytorch/.gitignore
 create mode 100755 pytorch/get_version.sh
 create mode 100644 pytorch/notebooks/autogluon_chronos.ipynb
 create mode 100644 tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb

diff --git a/.gitignore b/.gitignore
index 5dd1896..4a8ff28 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,3 +7,4 @@
 data
 *webp
 jupyter_gpu.code-workspace
+cvtt
diff --git a/pytorch/.gitignore b/pytorch/.gitignore
new file mode 100644
index 0000000..1263cad
--- /dev/null
+++ b/pytorch/.gitignore
@@ -0,0 +1 @@
+**/AutogluonModels/
diff --git a/pytorch/docker-compose.yml b/pytorch/docker-compose.yml
index 34404d8..7eab572 100644
--- a/pytorch/docker-compose.yml
+++ b/pytorch/docker-compose.yml
@@ -8,17 +8,19 @@ version: '3.8'
 services:
   jupyter:
     build: ${ROOT_DIR}
-    image: cvtt/jupyter_gpu_pt:v1.1.2
+    image: cvtt/jupyter_gpu_pt:v1.1.3
     container_name: jupyter_gpu_pt
     runtime: nvidia
     environment:
       - JUPYTER_ENABLE_LAB=yes
+      - PYTHONPATH=/cvtt/prod
     volumes:
       - ${ROOT_DIR}/notebooks:/workspace
       - ${ROOT_DIR}/jupyter_settings/user-settings:/root/.jupyter/lab/user-settings
       - ${ROOT_DIR}/jupyter_settings/workspaces:/root/.jupyter/lab/workspaces
       - ${ROOT_DIR}/.cache/torch:/root/.cache/torch
       - /opt/jupyter_gpu/data:/workspace/data
+      - ${ROOT_DIR}/cvtt:/cvtt
     ports:
       - "${JUPYTER_PORT}:${JUPYTER_PORT}"
     shm_size: "8gb"
diff --git a/pytorch/get_version.sh b/pytorch/get_version.sh
new file mode 100755
index 0000000..164c5d7
--- /dev/null
+++ b/pytorch/get_version.sh
@@ -0,0 +1,89 @@
+#!/bin/bash
+
+function usage() {
+    echo "Usage: ${0} <project> <version>"
+    exit 1
+
+}
+
+# ----- Settings
+Root=/opt/jupyter_gpu/pytorch/cvtt
+
+LocalSoftwareDir=${Root}/software/cvtt2
+ProdDir=${Root}/prod
+
+ReleaseHosts=("cloud21.cvtt.vpn")
+ReleasePorts=("22")
+ReleaseUsers=("cvttdist")
+ReleaseDir=("/home/cvttdist/software/cvtt2")
+# ----- Settings
+
+Project=${1}
+Version=${2}
+
+if [ "${Project}" == "" ]
+then
+    usage
+fi
+
+if [ "${Version}" == "" ]
+then
+    Version=latest
+fi
+
+
+function rsync_load_version() {
+    for idx in "${!ReleaseHosts[@]}"
+    do
+        host=${ReleaseHosts[${idx}]}
+        port=${ReleasePorts[${idx}]}
+        user=${ReleaseUsers[${idx}]}
+        rel_dir=${ReleaseDir[${idx}]}
+
+        if [ "${Version}" == "latest" ]; then
+            echo "Checking for latest version of ${Project} on ${user}@${host}:${rel_dir}"
+            Version=$(ssh -q -p ${port} ${user}@${host} "ls -tr ${rel_dir}/${Project} | tail -1" )
+            echo "Latest version is ${Version}"
+        fi
+        echo "Checking ${user}@${host} for ${rel_dir}/${Project}/${Version} ..."
+        if ssh -q -p ${port} ${user}@${host} "test -d ${rel_dir}/${Project}/${Version}"
+        then
+            echo "Directory found..."
+            rsync_cmd="rsync -ahvv -e \"ssh -p ${port}\""
+            rsync_cmd="${rsync_cmd} ${user}@${host}:${rel_dir}/${Project}/${Version}"
+            rsync_cmd="${rsync_cmd} ${LocalSoftwareDir}/${Project}/"
+            echo ${rsync_cmd}
+            eval ${rsync_cmd}
+            status=$?
+            if [ ${status} -eq 0 ]
+            then
+                echo "Loading successful..."
+                break
+            fi
+        else
+            echo "Not Found ${rel_dir}/${Project}/${Version} on ${user}@${host}"
+        fi
+    done
+    if [[ ! -d ${LocalSoftwareDir}/${Project} ]] ; then
+        echo ERROR loading software
+        exit 1
+    fi
+}
+
+mkdir -p ${LocalSoftwareDir}
+mkdir -p ${ProdDir}
+
+# exists and not empty
+rsync_load_version
+
+RelLocalSoftwareDir=../software/cvtt2
+Location="${RelLocalSoftwareDir}/${Project}/${Version}/${Project}"
+
+Cmd="cd ${ProdDir}"
+Cmd="${Cmd} && rm -rf ${Project}"
+Cmd="${Cmd} && ln -snf ${Location} ${Project}"
+
+echo ${Cmd} && eval ${Cmd}
+
+echo "Done: $0 $*"
+
diff --git a/pytorch/notebooks/Testing GPU.ipynb b/pytorch/notebooks/Testing GPU.ipynb
index 2104bc1..2878a5c 100644
--- a/pytorch/notebooks/Testing GPU.ipynb	
+++ b/pytorch/notebooks/Testing GPU.ipynb	
@@ -1,8 +1,16 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "53fb9dcb-843b-4633-b031-22236bfeb815",
+   "metadata": {},
+   "source": [
+    "### Check CUDA device"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 8,
    "id": "6b269e64-be58-43b5-ad60-0fbd1d37861a",
    "metadata": {},
    "outputs": [
@@ -27,90 +35,95 @@
    ]
   },
   {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "97906ea2-b284-4966-9c11-b8629f053815",
+   "cell_type": "markdown",
+   "id": "e6b4bc89-4cbd-4d4a-99a8-2d5bfb5d095d",
    "metadata": {},
-   "outputs": [],
    "source": [
-    "import plotly"
+    "### Environment"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 10,
    "id": "7313a620-a0eb-4207-a12a-90aeee3cd980",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "'3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]'"
+       "('3.10.13 (main, Sep 11 2023, 13:44:35) [GCC 11.2.0]',\n",
+       " environ{'PATH': '/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',\n",
+       "         'HOSTNAME': '6c24ffc52409',\n",
+       "         'JUPYTER_ENABLE_LAB': 'yes',\n",
+       "         'PYTHONPATH': '/cvtt/prod',\n",
+       "         'NVIDIA_VISIBLE_DEVICES': 'all',\n",
+       "         'NVIDIA_DRIVER_CAPABILITIES': 'compute,utility',\n",
+       "         'LD_LIBRARY_PATH': '/usr/local/nvidia/lib:/usr/local/nvidia/lib64',\n",
+       "         'PYTORCH_VERSION': '2.2.1',\n",
+       "         'HOME': '/root',\n",
+       "         'LC_CTYPE': 'C.UTF-8',\n",
+       "         'JPY_SESSION_NAME': '/workspace/Testing GPU.ipynb',\n",
+       "         'JPY_PARENT_PID': '1',\n",
+       "         'PYDEVD_USE_FRAME_EVAL': 'NO',\n",
+       "         'TERM': 'xterm-color',\n",
+       "         'CLICOLOR': '1',\n",
+       "         'FORCE_COLOR': '1',\n",
+       "         'CLICOLOR_FORCE': '1',\n",
+       "         'PAGER': 'cat',\n",
+       "         'GIT_PAGER': 'cat',\n",
+       "         'MPLBACKEND': 'module://matplotlib_inline.backend_inline',\n",
+       "         'CUDA_MODULE_LOADING': 'LAZY'})"
       ]
      },
-     "execution_count": 3,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "import sys\n",
-    "sys.version"
+    "sys.version,os.environ"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "943ac637-42c7-4a69-a6c4-94c382e22653",
+   "metadata": {},
+   "source": [
+    "### Test packages avai"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 11,
    "id": "95d9a2e6-3464-4dbe-9a97-0c2d5eb34193",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "environ{'PATH': '/opt/conda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin',\n",
-       "        'HOSTNAME': '1fc69c311e22',\n",
-       "        'JUPYTER_ENABLE_LAB': 'yes',\n",
-       "        'NVIDIA_VISIBLE_DEVICES': 'all',\n",
-       "        'NVIDIA_DRIVER_CAPABILITIES': 'compute,utility',\n",
-       "        'LD_LIBRARY_PATH': '/usr/local/nvidia/lib:/usr/local/nvidia/lib64',\n",
-       "        'PYTORCH_VERSION': '2.2.1',\n",
-       "        'HOME': '/root',\n",
-       "        'LC_CTYPE': 'C.UTF-8',\n",
-       "        'JPY_SESSION_NAME': '/workspace/oleg/Testing GPU.ipynb',\n",
-       "        'JPY_PARENT_PID': '1',\n",
-       "        'PYDEVD_USE_FRAME_EVAL': 'NO',\n",
-       "        'TERM': 'xterm-color',\n",
-       "        'CLICOLOR': '1',\n",
-       "        'FORCE_COLOR': '1',\n",
-       "        'CLICOLOR_FORCE': '1',\n",
-       "        'PAGER': 'cat',\n",
-       "        'GIT_PAGER': 'cat',\n",
-       "        'MPLBACKEND': 'module://matplotlib_inline.backend_inline',\n",
-       "        'CUDA_MODULE_LOADING': 'LAZY'}"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
     "import matplotlib\n",
-    "os.environ"
+    "import plotly\n",
+    "\n",
+    "import cvttpy.tools.timeutils as tu\n",
+    "\n",
+    "import autogluon\n",
+    "\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 12,
    "id": "eb38de31-fc19-4515-b08d-9cd7607ea958",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "application/vnd.jupyter.widget-view+json": {
-       "model_id": "75642bda0eed47598e340b8c1766949a",
+       "model_id": "2b2a98cdd61d477b811279a6753630a2",
        "version_major": 2,
        "version_minor": 0
       },
@@ -127,42 +140,37 @@
      "text": [
       "Done\n"
      ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "1717721060059418080"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
     }
    ],
    "source": [
     "import ipywidgets\n",
     "from ipywidgets import interact, IntSlider\n",
+    "import cvttpy.tools.timeutils as tu\n",
     "\n",
     "def f(x):\n",
     "    return x\n",
     "\n",
     "interact(f, x=IntSlider(min=0, max=10, step=1, value=5))\n",
-    "print(\"Done\")\n"
+    "print(\"Done\")\n",
+    "tu.current_nanoseconds()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "id": "f46e46a7-9b57-44aa-9bc9-dcbcf643bc88",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "jupyter-events==0.10.0\n",
-      "jupyter-lsp==2.2.5\n",
-      "jupyter_client==8.6.2\n",
-      "jupyter_core==5.7.2\n",
-      "jupyter_server==2.14.1\n",
-      "jupyter_server_terminals==0.5.3\n",
-      "jupyterlab==4.2.1\n",
-      "jupyterlab_pygments==0.3.0\n",
-      "jupyterlab_server==2.27.2\n",
-      "jupyterlab_widgets==3.0.11\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!pip freeze | grep jupyter"
    ]
diff --git a/pytorch/notebooks/autogluon_chronos.ipynb b/pytorch/notebooks/autogluon_chronos.ipynb
new file mode 100644
index 0000000..9e18847
--- /dev/null
+++ b/pytorch/notebooks/autogluon_chronos.ipynb
@@ -0,0 +1,391 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1b729e5b-09ec-42b6-ad6d-4b4c8947ae20",
+   "metadata": {},
+   "source": [
+    "https://auto.gluon.ai/stable/tutorials/timeseries/forecasting-chronos.html"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1b98681b-7136-4726-bf1f-433910162939",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import pandas as pd\n",
+    "from autogluon.timeseries import TimeSeriesDataFrame, TimeSeriesPredictor\n",
+    "\n",
+    "home = os.environ['HOME']\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "be0a08ef-bd1e-4ef8-a776-d6289670a35b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def load_df_from_db(file: str, query: str) -> pd.DataFrame:\n",
+    "    import sqlite3 \n",
+    "    \n",
+    "    conn = sqlite3.connect(file)\n",
+    "    df = pd.read_sql_query(query, conn)\n",
+    "    df['timestamp'] = pd.to_datetime(df['tstamp'])\n",
+    "    df.set_index('timestamp', inplace=True)\n",
+    "    return df\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "16175ced-b6ed-4b6f-af7f-22208a867f71",
+   "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>id</th>\n",
+       "      <th>tstamp</th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717200000000000000</td>\n",
+       "      <td>67566.835981</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717200060000000000</td>\n",
+       "      <td>67575.014916</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717200120000000000</td>\n",
+       "      <td>67572.550101</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717200180000000000</td>\n",
+       "      <td>67600.476125</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717200240000000000</td>\n",
+       "      <td>67636.363585</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1435</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717286100000000000</td>\n",
+       "      <td>67753.782261</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1436</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717286160000000000</td>\n",
+       "      <td>67755.991209</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1437</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717286220000000000</td>\n",
+       "      <td>67755.991295</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1438</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717286280000000000</td>\n",
+       "      <td>67763.063589</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1439</th>\n",
+       "      <td>PAIR-BTC-USDT</td>\n",
+       "      <td>1717286340000000000</td>\n",
+       "      <td>67768.060160</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1440 rows × 3 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 id               tstamp        target\n",
+       "0     PAIR-BTC-USDT  1717200000000000000  67566.835981\n",
+       "1     PAIR-BTC-USDT  1717200060000000000  67575.014916\n",
+       "2     PAIR-BTC-USDT  1717200120000000000  67572.550101\n",
+       "3     PAIR-BTC-USDT  1717200180000000000  67600.476125\n",
+       "4     PAIR-BTC-USDT  1717200240000000000  67636.363585\n",
+       "...             ...                  ...           ...\n",
+       "1435  PAIR-BTC-USDT  1717286100000000000  67753.782261\n",
+       "1436  PAIR-BTC-USDT  1717286160000000000  67755.991209\n",
+       "1437  PAIR-BTC-USDT  1717286220000000000  67755.991295\n",
+       "1438  PAIR-BTC-USDT  1717286280000000000  67763.063589\n",
+       "1439  PAIR-BTC-USDT  1717286340000000000  67768.060160\n",
+       "\n",
+       "[1440 rows x 3 columns]"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "file_path = \"/workspace/data/crypto_md/20240601.mktdata.ohlcv.db\"\n",
+    "instrument_id='PAIR-BTC-USDT'\n",
+    "query = f\"select '{instrument_id}' as id, tstamp, vwap from bnbspot_ohlcv_1min where instrument_id = '{instrument_id}'\"\n",
+    "df = load_df_from_db(file=file_path, query=query)\n",
+    "df.rename(columns={'vwap': 'target'}, inplace=True)\n",
+    "# df[\"tstamp2\"] = df.index\n",
+    "df = df.reset_index()\n",
+    "df = df.drop([\"timestamp\"], axis=1) \n",
+    "df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "b23fbb91-d5a2-40d2-85fe-30581d745ac6",
+   "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></th>\n",
+       "      <th>target</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>item_id</th>\n",
+       "      <th>timestamp</th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th rowspan=\"5\" valign=\"top\">PAIR-BTC-USDT</th>\n",
+       "      <th>2024-06-01 00:00:00</th>\n",
+       "      <td>67566.835981</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-06-01 00:01:00</th>\n",
+       "      <td>67575.014916</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-06-01 00:02:00</th>\n",
+       "      <td>67572.550101</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-06-01 00:03:00</th>\n",
+       "      <td>67600.476125</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2024-06-01 00:04:00</th>\n",
+       "      <td>67636.363585</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                         target\n",
+       "item_id       timestamp                        \n",
+       "PAIR-BTC-USDT 2024-06-01 00:00:00  67566.835981\n",
+       "              2024-06-01 00:01:00  67575.014916\n",
+       "              2024-06-01 00:02:00  67572.550101\n",
+       "              2024-06-01 00:03:00  67600.476125\n",
+       "              2024-06-01 00:04:00  67636.363585"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "data = TimeSeriesDataFrame.from_data_frame(\n",
+    "    df,\n",
+    "    id_column=\"id\",\n",
+    "    timestamp_column=\"tstamp\"\n",
+    ")\n",
+    "data.head()\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "cd7b6927-1666-4a59-8f47-4c6a66b230e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Beginning AutoGluon training...\n",
+      "AutoGluon will save models to 'AutogluonModels/ag-20240606_225207'\n",
+      "=================== System Info ===================\n",
+      "AutoGluon Version:  1.1.0\n",
+      "Python Version:     3.10.13\n",
+      "Operating System:   Linux\n",
+      "Platform Machine:   x86_64\n",
+      "Platform Version:   #117-Ubuntu SMP Fri Apr 26 12:26:49 UTC 2024\n",
+      "CPU Count:          8\n",
+      "GPU Count:          1\n",
+      "Memory Avail:       54.82 GB / 62.72 GB (87.4%)\n",
+      "Disk Space Avail:   429.42 GB / 476.94 GB (90.0%)\n",
+      "===================================================\n",
+      "Setting presets to: chronos_small\n",
+      "\n",
+      "Fitting with arguments:\n",
+      "{'enable_ensemble': True,\n",
+      " 'eval_metric': WQL,\n",
+      " 'hyperparameters': {'Chronos': {'model_path': 'small'}},\n",
+      " 'known_covariates_names': [],\n",
+      " 'num_val_windows': 1,\n",
+      " 'prediction_length': 10,\n",
+      " 'quantile_levels': [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],\n",
+      " 'random_seed': 123,\n",
+      " 'refit_every_n_windows': 1,\n",
+      " 'refit_full': False,\n",
+      " 'skip_model_selection': True,\n",
+      " 'target': 'target',\n",
+      " 'verbosity': 2}\n",
+      "\n",
+      "Inferred time series frequency: 'min'\n",
+      "Provided train_data has 1430 rows, 1 time series. Median time series length is 1430 (min=1430, max=1430). \n",
+      "\n",
+      "Provided data contains following columns:\n",
+      "\ttarget: 'target'\n",
+      "\n",
+      "AutoGluon will gauge predictive performance using evaluation metric: 'WQL'\n",
+      "\tThis metric's sign has been flipped to adhere to being higher_is_better. The metric score can be multiplied by -1 to get the metric value.\n",
+      "===================================================\n",
+      "\n",
+      "Starting training. Start time is 2024-06-06 22:52:07\n",
+      "Models that will be trained: ['Chronos[small]']\n",
+      "Training timeseries model Chronos[small]. \n",
+      "\t0.00    s     = Training runtime\n",
+      "Training complete. Models trained: ['Chronos[small]']\n",
+      "Total runtime: 0.00 s\n",
+      "Best model: Chronos[small]\n"
+     ]
+    }
+   ],
+   "source": [
+    "prediction_length = 10\n",
+    "train_data, test_data = data.train_test_split(prediction_length)\n",
+    "\n",
+    "predictor = TimeSeriesPredictor(prediction_length=prediction_length).fit(\n",
+    "    train_data, presets=\"chronos_small\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "36b063a8-365f-45cb-80f7-8b5b625f42e9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Model not specified in predict, will default to the model with the best validation score: Chronos[small]\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x350 with 1 Axes>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "predictions = predictor.predict(train_data)\n",
+    "predictor.plot(\n",
+    "    data=data, \n",
+    "    predictions=predictions, \n",
+    "    max_history_length=200,\n",
+    ")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tensorflow/notebooks/Testing GPU.ipynb b/tensorflow/notebooks/Testing GPU.ipynb
index 324021e..1c89d20 100644
--- a/tensorflow/notebooks/Testing GPU.ipynb	
+++ b/tensorflow/notebooks/Testing GPU.ipynb	
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "id": "000d047d-3dfd-48cb-a3c3-bd1ad7c78b71",
    "metadata": {},
    "outputs": [
@@ -55,6 +55,14 @@
     "for gpu in gpus:\n",
     "    print(gpu)"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "080fdf50-a5d5-4650-8f29-34c773443d59",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb b/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb
new file mode 100644
index 0000000..180420f
--- /dev/null
+++ b/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb
@@ -0,0 +1,443 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1023f2c1-e45f-4e1c-9a1b-66f59f128196",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Panda Version: 2.2.2\n",
+      "Today date is:  2024-06-06\n"
+     ]
+    }
+   ],
+   "source": [
+    "import sqlite3\n",
+    "\n",
+    "import numpy as np\n",
+    "# It is apparently officially accepted to explicitly\n",
+    "# list all the functions you need from numpy:\n",
+    "from numpy import array, zeros, exp, random, dot\n",
+    "from numpy import shape, reshape, meshgrid, linspace\n",
+    "from numpy import hstack, vstack\n",
+    "\n",
+    "import pandas as pd\n",
+    "print('Panda Version:', pd.__version__)\n",
+    "\n",
+    "# Set ipython's max row display\n",
+    "pd.set_option('display.max_row', 100, 'display.max_columns', 25)\n",
+    "\n",
+    "import matplotlib.pyplot as plt # for plotting\n",
+    "import matplotlib\n",
+    "matplotlib.rcParams['figure.dpi'] = 100 # highres display\n",
+    "\n",
+    "import tensorflow as tf\n",
+    "from tensorflow import Variable\n",
+    "\n",
+    "from tensorflow.keras import Sequential\n",
+    "from tensorflow.keras import Model\n",
+    "from tensorflow.keras.layers import Dense\n",
+    "from tensorflow.keras.layers import Dropout\n",
+    "from tensorflow.keras.layers import TimeDistributed, RepeatVector\n",
+    "\n",
+    "from keras.optimizers import SGD\n",
+    "\n",
+    "from keras.models import load_model\n",
+    "from keras.callbacks import EarlyStopping\n",
+    "from keras.callbacks import ModelCheckpoint\n",
+    "\n",
+    "from keras.layers import LSTM, Dense, Concatenate\n",
+    "\n",
+    "from keras.optimizers import SGD\n",
+    "\n",
+    "import collections\n",
+    "from collections import Counter\n",
+    "\n",
+    "# Import date class from datetime module\n",
+    "import time\n",
+    "# import datetime as dt\n",
+    "from datetime import date, datetime\n",
+    "print(\"Today date is: \", date.today())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "c09a37a6-f0d9-48e3-a1d1-65ddaf2c489c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/workspace/leo\n",
+      "total 6528\n",
+      "drwxrwxr-x 1 oleg oleg     250 Jun  6 10:00 .\n",
+      "drwxrwxr-x 1 oleg oleg      18 Jun  3 23:40 ..\n",
+      "-rw------- 1 oleg oleg 1449984 Jun  4 00:49 20240601.mktdata.ohlcv.db\n",
+      "-rw------- 1 oleg oleg 1445888 Jun  3 23:44 20240602.mktdata.ohlcv.db\n",
+      "-rw------- 1 oleg oleg 1437696 Jun  4 16:45 20240603.mktdata.ohlcv.db\n",
+      "-rw------- 1 oleg oleg 1269760 Jun  5 10:00 20240604.mktdata.ohlcv.db\n",
+      "-rw------- 1 oleg oleg 1081344 Jun  6 10:00 20240605.mktdata.ohlcv.db\n"
+     ]
+    }
+   ],
+   "source": [
+    "!pwd\n",
+    "\n",
+    "!ls -la /workspace/data/crypto_md/"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "8d72d849-e8df-4564-a006-03ab646b9330",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "58d263ae-d028-4de0-9f10-0f14c4de28f7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mktdata_db_file = \"/workspace/data/crypto_md/20240601.mktdata.ohlcv.db\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "70033f48-f283-43f3-8e86-3bd533a10fed",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "db_conn = sqlite3.connect(mktdata_db_file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "2cb82c91-a487-46b1-bcd0-012f7675010f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "    type                 name             tbl_name  rootpage  \\\n",
+      "0  table    bnbfut_ohlcv_1min    bnbfut_ohlcv_1min         2   \n",
+      "1  table   bnbspot_ohlcv_1min   bnbspot_ohlcv_1min        66   \n",
+      "2  table  coinbase_ohlcv_1min  coinbase_ohlcv_1min       224   \n",
+      "\n",
+      "                                                 sql  \n",
+      "0  CREATE TABLE bnbfut_ohlcv_1min (tstamp INTEGER...  \n",
+      "1  CREATE TABLE bnbspot_ohlcv_1min (tstamp INTEGE...  \n",
+      "2  CREATE TABLE coinbase_ohlcv_1min (tstamp INTEG...  \n"
+     ]
+    }
+   ],
+   "source": [
+    "tables_df = pd.read_sql_query(\"select * from sqlite_master where type = 'table'\", db_conn)\n",
+    "print (tables_df.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "cf159bde-1ccc-40e0-9eb9-a010c1372e07",
+   "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>tstamp</th>\n",
+       "      <th>exchange_id</th>\n",
+       "      <th>instrument_id</th>\n",
+       "      <th>open</th>\n",
+       "      <th>high</th>\n",
+       "      <th>low</th>\n",
+       "      <th>close</th>\n",
+       "      <th>volume</th>\n",
+       "      <th>vwap</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>5754</th>\n",
+       "      <td>1717286100000000000</td>\n",
+       "      <td>COINBASE</td>\n",
+       "      <td>PAIR-XRP-USD</td>\n",
+       "      <td>0.5183</td>\n",
+       "      <td>0.5183</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>7401.243996</td>\n",
+       "      <td>0.518096</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5755</th>\n",
+       "      <td>1717286160000000000</td>\n",
+       "      <td>COINBASE</td>\n",
+       "      <td>PAIR-XRP-USD</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>0.5182</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>3491.632415</td>\n",
+       "      <td>0.518020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5756</th>\n",
+       "      <td>1717286220000000000</td>\n",
+       "      <td>COINBASE</td>\n",
+       "      <td>PAIR-XRP-USD</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>0.5180</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>6963.191620</td>\n",
+       "      <td>0.518095</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5757</th>\n",
+       "      <td>1717286280000000000</td>\n",
+       "      <td>COINBASE</td>\n",
+       "      <td>PAIR-XRP-USD</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>0.5183</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>0.5182</td>\n",
+       "      <td>35743.462893</td>\n",
+       "      <td>0.518140</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5758</th>\n",
+       "      <td>1717286340000000000</td>\n",
+       "      <td>COINBASE</td>\n",
+       "      <td>PAIR-XRP-USD</td>\n",
+       "      <td>0.5182</td>\n",
+       "      <td>0.5184</td>\n",
+       "      <td>0.5181</td>\n",
+       "      <td>0.5184</td>\n",
+       "      <td>45521.897366</td>\n",
+       "      <td>0.518245</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                   tstamp exchange_id instrument_id    open    high     low  \\\n",
+       "5754  1717286100000000000    COINBASE  PAIR-XRP-USD  0.5183  0.5183  0.5180   \n",
+       "5755  1717286160000000000    COINBASE  PAIR-XRP-USD  0.5180  0.5182  0.5180   \n",
+       "5756  1717286220000000000    COINBASE  PAIR-XRP-USD  0.5181  0.5181  0.5180   \n",
+       "5757  1717286280000000000    COINBASE  PAIR-XRP-USD  0.5181  0.5183  0.5181   \n",
+       "5758  1717286340000000000    COINBASE  PAIR-XRP-USD  0.5182  0.5184  0.5181   \n",
+       "\n",
+       "       close        volume      vwap  \n",
+       "5754  0.5180   7401.243996  0.518096  \n",
+       "5755  0.5180   3491.632415  0.518020  \n",
+       "5756  0.5181   6963.191620  0.518095  \n",
+       "5757  0.5182  35743.462893  0.518140  \n",
+       "5758  0.5184  45521.897366  0.518245  "
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df = pd.read_sql_query(\"select * from coinbase_ohlcv_1min\", db_conn)\n",
+    "df.tail()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "11d73b0a-fe9b-4d73-87c3-4250ef98b16a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# 0601 - 0605"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cd83027c-eaa1-44d9-98ad-8506099c323d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "6ccc60bc-6b74-408c-946c-bdbfee0cffb5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0f358ee5-9ec0-4582-be09-4e4ad84faca7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fab70130-9661-4efd-ad45-7647d81cc6ce",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "77504183-34d8-42c6-93a3-d86a34388f9e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "                                  tstamp exchange_id instrument_id      open  \\\n",
+      "timestamp                                                                      \n",
+      "2024-06-01 00:00:00  1717200000000000000    COINBASE  PAIR-BTC-USD  67473.07   \n",
+      "2024-06-01 00:01:00  1717200060000000000    COINBASE  PAIR-BTC-USD  67506.57   \n",
+      "2024-06-01 00:02:00  1717200120000000000    COINBASE  PAIR-BTC-USD  67494.73   \n",
+      "2024-06-01 00:03:00  1717200180000000000    COINBASE  PAIR-BTC-USD  67512.78   \n",
+      "2024-06-01 00:04:00  1717200240000000000    COINBASE  PAIR-BTC-USD  67538.81   \n",
+      "\n",
+      "                         high       low     close    volume          vwap  \n",
+      "timestamp                                                                  \n",
+      "2024-06-01 00:00:00  67514.99  67468.13  67506.03  2.045049  67496.869352  \n",
+      "2024-06-01 00:01:00  67515.00  67480.66  67494.74  0.646759  67500.893305  \n",
+      "2024-06-01 00:02:00  67515.00  67455.91  67514.99  9.732906  67477.840770  \n",
+      "2024-06-01 00:03:00  67553.85  67496.58  67539.76  4.374730  67522.912057  \n",
+      "2024-06-01 00:04:00  67579.13  67530.05  67579.13  2.215383  67557.086208  \n"
+     ]
+    }
+   ],
+   "source": [
+    "df[\"timestamp\"] = pd.to_datetime(df['tstamp'], unit='ns')\n",
+    "df.set_index(\"timestamp\", inplace=True)\n",
+    "print (df.head())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "316c0cfb-c73d-4dad-9d49-eb80daa229ec",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "92700c76-8eac-4ebb-86d3-27066486c437",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3604f3f2-3e56-477d-a7ac-d6490839642d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df_union = pd.read_sql_query(\"select * from coinbase_ohlcv_1min\", db_conn)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a7c8b332-cd4a-455f-b7cf-381aec15c456",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0a27972a-f457-4ca5-8530-d6c87c7d9d91",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b5356525-e614-4858-af4e-648c03b7d21e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "695de24a-41f4-4c82-a0dd-dbbd7bfba2bd",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3c6d80b3-4a46-432b-9b88-6a264f9b7a7e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.0rc1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}