diff --git a/pytorch/.env b/pytorch/.env index 6da144b..ce603d5 100644 --- a/pytorch/.env +++ b/pytorch/.env @@ -1,2 +1,5 @@ ROOT_DIR=/opt/jupyter_gpu/pytorch +DATA_DIR=/opt/jupyter_gpu/data JUPYTER_PORT=8888 +PUID=1000 +PGID=1000 diff --git a/pytorch/docker-compose.yml b/pytorch/docker-compose.yml index 7eab572..b60d99c 100644 --- a/pytorch/docker-compose.yml +++ b/pytorch/docker-compose.yml @@ -3,24 +3,32 @@ version: '3.8' #================================================== # Relies on the file `.env` content for varables: # ROOT_DIR +# DATA_DIR # JUPYTER_PORT +# UID +# GID #================================================== services: jupyter: + user: "${UID}:${GID}" build: ${ROOT_DIR} - image: cvtt/jupyter_gpu_pt:v1.1.3 + image: cvtt/jupyter_gpu_pt:v1.1.5 container_name: jupyter_gpu_pt runtime: nvidia + restart: unless-stopped environment: - JUPYTER_ENABLE_LAB=yes - PYTHONPATH=/cvtt/prod +# security_opt: +# - no-new-privileges:true 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 + + - ${DATA_DIR}:/workspace/data ports: - "${JUPYTER_PORT}:${JUPYTER_PORT}" shm_size: "8gb" diff --git a/pytorch/notebooks/Testing GPU.ipynb b/pytorch/notebooks/Testing GPU.ipynb index c4ad3e7..333b641 100644 --- a/pytorch/notebooks/Testing GPU.ipynb +++ b/pytorch/notebooks/Testing GPU.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "6b269e64-be58-43b5-ad60-0fbd1d37861a", "metadata": {}, "outputs": [ @@ -51,19 +51,49 @@ { "data": { "text/plain": [ - "('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", + "('3.10.12 (main, Nov 20 2023, 15:14:05) [GCC 11.4.0]',\n", + " environ{'USER': 'oleg',\n", + " 'SSH_CLIENT': '100.102.18.30 39290 22',\n", + " 'XDG_SESSION_TYPE': 'tty',\n", + " 'SHLVL': '1',\n", + " 'MOTD_SHOWN': 'pam',\n", + " 'HOME': '/home/oleg',\n", + " 'OLDPWD': '/home/oleg/.vscode-server',\n", + " 'SSL_CERT_FILE': '/usr/lib/ssl/certs/ca-certificates.crt',\n", + " 'DBUS_SESSION_BUS_ADDRESS': 'unix:path=/run/user/1000/bus',\n", + " 'LOGNAME': 'oleg',\n", + " '_': '/home/oleg/.pyenv/python3.10-venv/bin/python',\n", + " 'XDG_SESSION_CLASS': 'user',\n", + " 'VSCODE_CLI_REQUIRE_TOKEN': 'a18f8694-adf8-4fa9-a860-a18b2bdb3d92',\n", + " 'XDG_SESSION_ID': '149',\n", + " 'PATH': '/home/oleg/.pyenv/python3.10-venv/bin:/home/oleg/.vscode-server/cli/servers/Stable-dc96b837cf6bb4af9cd736aa3af08cf8279f7685/server/bin/remote-cli:/usr/local/cuda/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin',\n", + " 'VSCODE_AGENT_FOLDER': '/home/oleg/.vscode-server',\n", + " 'XDG_RUNTIME_DIR': '/run/user/1000',\n", + " 'SSL_CERT_DIR': '/usr/lib/ssl/certs',\n", + " 'LANG': 'en_US.UTF-8',\n", + " 'SHELL': '/bin/bash',\n", + " 'PWD': '/home/oleg',\n", + " 'SSH_CONNECTION': '100.102.18.30 39290 100.102.233.115 22',\n", + " 'XDG_DATA_DIRS': '/home/oleg/.local/share/flatpak/exports/share:/var/lib/flatpak/exports/share:/usr/local/share:/usr/share',\n", + " 'VSCODE_HANDLES_SIGPIPE': 'true',\n", + " 'LS_COLORS': '',\n", + " 'LESSCLOSE': '/usr/bin/lesspipe %s %s',\n", + " 'LESSOPEN': '| /usr/bin/lesspipe %s',\n", + " 'LD_LIBRARY_PATH': '/usr/local/cuda/lib64',\n", + " 'VSCODE_AMD_ENTRYPOINT': 'vs/workbench/api/node/extensionHostProcess',\n", + " 'VSCODE_HANDLES_UNCAUGHT_ERRORS': 'true',\n", + " 'VSCODE_NLS_CONFIG': '{\"locale\":\"en\",\"osLocale\":\"en\",\"availableLanguages\":{}}',\n", + " 'BROWSER': '/home/oleg/.vscode-server/cli/servers/Stable-dc96b837cf6bb4af9cd736aa3af08cf8279f7685/server/bin/helpers/browser.sh',\n", + " 'VSCODE_CWD': '/home/oleg',\n", + " 'ELECTRON_RUN_AS_NODE': '1',\n", + " 'VSCODE_IPC_HOOK_CLI': '/run/user/1000/vscode-ipc-c5d6268a-2e45-4659-9523-6fcffb529a08.sock',\n", + " 'PYTHONUNBUFFERED': '1',\n", + " 'VIRTUAL_ENV': '/home/oleg/.pyenv/python3.10-venv',\n", + " 'PYTHONIOENCODING': 'utf-8',\n", + " 'VIRTUAL_ENV_PROMPT': '(python3.10-venv) ',\n", + " 'PS1': '(python3.10-venv) ',\n", + " 'PYDEVD_IPYTHON_COMPATIBLE_DEBUGGING': '1',\n", + " 'PYTHON_FROZEN_MODULES': 'on',\n", " 'PYDEVD_USE_FRAME_EVAL': 'NO',\n", " 'TERM': 'xterm-color',\n", " 'CLICOLOR': '1',\n", @@ -82,7 +112,11 @@ ], "source": [ "import sys\n", - "sys.version,os.environ" + "import os\n", + "\n", + "sys.path.append(\"/home/oleg/develop/cvtt2\")\n", + "sys.version,os.environ\n", + "\n" ] }, { @@ -131,12 +165,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2b2a98cdd61d477b811279a6753630a2", + "model_id": "4be0c8cc9c004ef6b32f044018434a85", "version_major": 2, "version_minor": 0 }, "text/plain": [ - "interactive(children=(IntSlider(value=5, description='x', max=10), Output()), _dom_classes=('widget-interact',…" + "interactive(children=(IntSlider(value=5, description='x', max=1000), Output()), _dom_classes=('widget-interact…" ] }, "metadata": {}, @@ -152,7 +186,7 @@ { "data": { "text/plain": [ - "1717721060059418080" + "1718155463838047267" ] }, "execution_count": 12, @@ -168,17 +202,27 @@ "def f(x):\n", " return x\n", "\n", - "interact(f, x=IntSlider(min=0, max=10, step=1, value=5))\n", + "interact(f, x=IntSlider(min=0, max=1000, step=1, value=5))\n", "print(\"Done\")\n", "tu.current_nanoseconds()" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "f46e46a7-9b57-44aa-9bc9-dcbcf643bc88", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "jupyter_client==8.6.2\n", + "jupyter_core==5.7.2\n", + "jupyterlab_widgets==3.0.11\n" + ] + } + ], "source": [ "!pip freeze | grep jupyter" ] @@ -200,7 +244,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.13" + "version": "3.10.12" } }, "nbformat": 4, diff --git a/tensorflow/.env b/tensorflow/.env index 267b92a..c4a70cf 100644 --- a/tensorflow/.env +++ b/tensorflow/.env @@ -1,2 +1,3 @@ ROOT_DIR=/opt/jupyter_gpu/tensorflow +DATA_DIR=/opt/jupyter_gpu/data JUPYTER_PORT=9999 diff --git a/tensorflow/docker-compose.yml b/tensorflow/docker-compose.yml index e13acb6..98501b1 100644 --- a/tensorflow/docker-compose.yml +++ b/tensorflow/docker-compose.yml @@ -3,6 +3,7 @@ version: '3.8' #================================================== # Relies on the file `.env` content for varables: # ROOT_DIR +# DATA_DIR # JUPYTER_PORT #================================================== @@ -10,7 +11,7 @@ services: jupyter: # user: "oleg" build: ${ROOT_DIR} - image: cvtt/jupyter_gpu_tf:v1.0.5 + image: cvtt/jupyter_gpu_tf:v1.0.6 container_name: jupyter_gpu_tf runtime: nvidia environment: @@ -20,7 +21,7 @@ services: - ${ROOT_DIR}/notebooks:/workspace - ${ROOT_DIR}/jupyter_settings/user-settings:/home/oleg/.jupyter/lab/user-settings - ${ROOT_DIR}/jupyter_settings/workspaces:/home/oleg/.jupyter/lab/workspaces - - /opt/jupyter_gpu/data:/workspace/data + - ${DATA_DIR}:/workspace/data ports: - "${JUPYTER_PORT}:${JUPYTER_PORT}" shm_size: "8gb" diff --git a/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb b/tensorflow/notebooks/leo/LSTM_All_Crypto_01.ipynb index 180420f..6e18e1c 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": 4, + "execution_count": 114, "id": "1023f2c1-e45f-4e1c-9a1b-66f59f128196", "metadata": {}, "outputs": [ @@ -11,13 +11,16 @@ "output_type": "stream", "text": [ "Panda Version: 2.2.2\n", - "Today date is: 2024-06-06\n" + "Today date is: 2024-06-12\n" ] } ], "source": [ "import sqlite3\n", "\n", + "import os\n", + "import re\n", + "\n", "import numpy as np\n", "# It is apparently officially accepted to explicitly\n", "# list all the functions you need from numpy:\n", @@ -59,14 +62,15 @@ "\n", "# Import date class from datetime module\n", "import time\n", + "import datetime\n", "# import datetime as dt\n", - "from datetime import date, datetime\n", + "from datetime import date\n", "print(\"Today date is: \", date.today())" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 115, "id": "c09a37a6-f0d9-48e3-a1d1-65ddaf2c489c", "metadata": {}, "outputs": [ @@ -75,14 +79,21 @@ "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" + "total 14988\n", + "drwxrwxr-x 1 1000 1000 598 Jun 12 15:29 .\n", + "drwxrwxr-x 1 1000 1000 18 Jun 3 23:40 ..\n", + "-rw------- 1 1000 1000 1449984 Jun 4 00:49 20240601.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 3 23:44 20240602.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 4 16:45 20240603.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1269760 Jun 5 10:00 20240604.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1081344 Jun 6 10:00 20240605.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1441792 Jun 7 10:00 20240606.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1445888 Jun 8 10:00 20240607.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 9 10:00 20240608.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1437696 Jun 10 10:00 20240609.mktdata.ohlcv.db\n", + "-rw-r--r-- 1 1000 1000 0 Jun 12 15:29 20240609.mktdata.ohlcvdb\n", + "-rw------- 1 1000 1000 1437696 Jun 11 10:00 20240610.mktdata.ohlcv.db\n", + "-rw------- 1 1000 1000 1449984 Jun 12 10:01 20240611.mktdata.ohlcv.db\n" ] } ], @@ -94,288 +105,241 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 82, "id": "8d72d849-e8df-4564-a006-03ab646b9330", "metadata": {}, "outputs": [], + "source": [ + "# db_conn = sqlite3.connect(mktdata_db_file)\n", + "# tables_df = pd.read_sql_query(\"select * from sqlite_master where type = 'table'\", db_conn)\n", + "# print (tables_df_20240601.head())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4df4b0d4-e92e-42a9-8747-ff60669a4e10", + "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", + "execution_count": 128, + "id": "5d2aed0b-8c9d-4f5a-9166-785da4811390", "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", + "5759\n", + "11519\n", + "17213\n", + "22272\n", + "26556\n", + "32316\n", + "38076\n", + "43836\n", + "49596\n", + "55283\n", + " tstamp exchange_id instrument_id open high \\\n", + "0 1717200000000000000 COINBASE PAIR-BTC-USD 67473.07 67514.99 \n", + "1 1717200060000000000 COINBASE PAIR-BTC-USD 67506.57 67515.00 \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" + " low close volume vwap \n", + "0 67468.13 67506.03 2.045049 67496.869352 \n", + "1 67480.66 67494.74 0.646759 67500.893305 \n", + " tstamp exchange_id instrument_id open high low \\\n", + "55281 1718063880000000000 COINBASE PAIR-XRP-USD 0.4968 0.4968 0.4966 \n", + "55282 1718063940000000000 COINBASE PAIR-XRP-USD 0.4967 0.4967 0.4966 \n", + "\n", + " close volume vwap \n", + "55281 0.4967 9143.928579 0.496704 \n", + "55282 0.4967 3314.651869 0.496681 \n" ] } ], "source": [ - "tables_df = pd.read_sql_query(\"select * from sqlite_master where type = 'table'\", db_conn)\n", - "print (tables_df.head())" + "directory = \"/workspace/data/crypto_md\"\n", + "\n", + "# List of dates\n", + "dates = ['20240601', \n", + " '20240602', \n", + " '20240603', \n", + " '20240604', \n", + " '20240605', \n", + " '20240606', \n", + " '20240607', \n", + " '20240608', \n", + " '20240609',\n", + " '20240610']\n", + " \n", + "# '20240601', '20240602', '20240601', '20240602'\n", + "\n", + "# Create an entirely empty DataFrame\n", + "df_concat = pd.DataFrame()\n", + "\n", + "for date in dates:\n", + " # Construct the filename\n", + " filename = f\"{directory}/{date}.mktdata.ohlcv.db\"\n", + " \n", + " # Create the SQLite connection\n", + " conn = sqlite3.connect(filename)\n", + " \n", + " # Read the data into a DataFrame\n", + " df = pd.read_sql_query(\"select * from coinbase_ohlcv_1min\", conn)\n", + "\n", + " df_concat = pd.concat([df_concat, df], axis = 0,ignore_index = True)\n", + " \n", + " # Print the combined DataFrame\n", + " print(df_concat.shape[0])\n", + " # print(df_concat.shape[1])\n", + "\n", + " conn.close()\n", + "\n", + "print(df_concat.head(2))\n", + "print(df_concat.tail(2))" ] }, { "cell_type": "code", - "execution_count": 34, - "id": "cf159bde-1ccc-40e0-9eb9-a010c1372e07", + "execution_count": 129, + "id": "cd83027c-eaa1-44d9-98ad-8506099c323d", + "metadata": {}, + "outputs": [], + "source": [ + "df_concat['tstamp'] = pd.to_datetime(df_concat['tstamp'])\n", + "# Extract individual components\n", + "df_concat['year'] = df_concat['tstamp'].dt.year\n", + "df_concat['month'] = df_concat['tstamp'].dt.month\n", + "df_concat['day'] = df_concat['tstamp'].dt.day\n", + "df_concat['hour'] = df_concat['tstamp'].dt.hour\n", + "df_concat['minute'] = df_concat['tstamp'].dt.minute\n", + "df_concat['second'] = df_concat['tstamp'].dt.second\n", + "\n", + "df_concat['date'] = df_concat['day'].astype(str) + '-' + df_concat['hour'].astype(str) + '-' + df_concat['minute'].astype(str)\n", + "df_concat = df_concat.sort_values(by = ['day', 'hour', 'minute'])\n", + "\n", + "selected_columns = ['date', 'instrument_id', 'close', 'volume', 'vwap']\n", + "df_concat = df_concat[selected_columns]" + ] + }, + { + "cell_type": "code", + "execution_count": 130, + "id": "6ccc60bc-6b74-408c-946c-bdbfee0cffb5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date instrument_id close volume vwap\n", + "0 1-0-0 PAIR-BTC-USD 67506.0300 2.045049 67496.869352\n", + "1440 1-0-0 PAIR-ETH-USD 3762.0400 37.497964 3761.077765\n", + "2880 1-0-0 PAIR-LTC-USD 83.1700 110.056253 83.166206\n", + "4319 1-0-0 PAIR-XRP-USD 0.5173 28809.165339 0.517217\n", + "1 1-0-1 PAIR-BTC-USD 67494.7400 0.646759 67500.893305\n" + ] + } + ], + "source": [ + "print(df_concat.head())\n", + "# print(df_concat.tail(2))" + ] + }, + { + "cell_type": "code", + "execution_count": 120, + "id": "0f358ee5-9ec0-4582-be09-4e4ad84faca7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distinct values in column 'instrument_id': ['PAIR-BTC-USD', 'PAIR-ETH-USD', 'PAIR-LTC-USD', 'PAIR-XRP-USD']\n" + ] + } + ], + "source": [ + "instrument_list = df_concat['instrument_id'].unique().tolist()\n", + "print(\"Distinct values in column 'instrument_id':\", instrument_list)" + ] + }, + { + "cell_type": "code", + "execution_count": 136, + "id": "316c0cfb-c73d-4dad-9d49-eb80daa229ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " date close_BTC volume_BTC vwap_BTC\n", + "0 1-0-0 0.675060 2.045049 0.674969\n", + "1 1-0-1 0.674947 0.646759 0.675009\n", + "2 1-0-2 0.675150 9.732906 0.674778\n" + ] + } + ], + "source": [ + "# BTC\n", + "df_concat_btc = df_concat[df_concat['instrument_id'] == 'PAIR-BTC-USD']\n", + "\n", + "# Reset Index\n", + "df_concat_btc = df_concat_btc.reset_index(drop = True)\n", + "\n", + "# Rename Vars\n", + "df_concat_btc['close_BTC'] = df_concat_btc['close']/100000.00\n", + "df_concat_btc['volume_BTC'] = df_concat_btc['volume']\n", + "df_concat_btc['vwap_BTC'] = df_concat_btc['vwap']/100000.00\n", + "\n", + "df_concat_btc = df_concat_btc.drop('close', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('volume', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('vwap', axis = 1)\n", + "df_concat_btc = df_concat_btc.drop('instrument_id', axis = 1)\n", + "\n", + "print (df_concat_btc.head(3))" + ] + }, + { + "cell_type": "code", + "execution_count": 140, + "id": "92700c76-8eac-4ebb-86d3-27066486c437", "metadata": {}, "outputs": [ { "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
tstampexchange_idinstrument_idopenhighlowclosevolumevwap
57541717286100000000000COINBASEPAIR-XRP-USD0.51830.51830.51800.51807401.2439960.518096
57551717286160000000000COINBASEPAIR-XRP-USD0.51800.51820.51800.51803491.6324150.518020
57561717286220000000000COINBASEPAIR-XRP-USD0.51810.51810.51800.51816963.1916200.518095
57571717286280000000000COINBASEPAIR-XRP-USD0.51810.51830.51810.518235743.4628930.518140
57581717286340000000000COINBASEPAIR-XRP-USD0.51820.51840.51810.518445521.8973660.518245
\n", - "
" - ], + "image/png": "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", "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" + "output_type": "display_data" } ], "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)" + "# Create a figure and axis object\n", + "fig, ax = plt.subplots(2 , 1)\n", + "\n", + "# Plot the data\n", + "ax[0].plot(df_concat_btc['date'], df_concat_btc['close_BTC'], 'blue')\n", + "# ax[0].plot(df_concat_btc['date'], df_concat_btc['vwap_BTC'], 'green')\n", + "\n", + "# Customize the plot\n", + "ax[0].set_title('PAIR-BTC-USDT')\n", + "ax[0].set_xlabel('date')\n", + "ax[0].set_ylabel('close')\n", + "\n", + "ax[1].plot(df_concat_btc['date'], df_concat_btc['vwap_BTC'], 'green')\n", + "# ax[1].plot(df_concat_btc['date'], df_concat_btc['volume_BTC'], 'red')\n", + "\n", + "# Show the plot\n", + "plt.show()" ] }, { diff --git a/tensorflow/notebooks/leo/filename b/tensorflow/notebooks/leo/filename new file mode 100644 index 0000000..e69de29