BTC_DAYLY_NN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b57acba-95af-4383-a2b2-0e2065cbe101",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ff88e0bd-a6f2-4e6b-8939-7373afc9e85d",
   "metadata": {},
   "outputs": [],
   "source": [
    "api_key = '####################'\n",
    "secret = '####################'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "26ce070a-360a-4bfd-8fc7-f7d0842227de",
   "metadata": {},
   "outputs": [],
   "source": [
    "from BTC import get_new_data, get_hist_data,indi_calc,strategy_calc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5b9feaac-b022-4f6f-85de-92d58b5c93e8",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import random\n",
    "from datetime import datetime\n",
    "from prophet import Prophet\n",
    "from binance.futures import Futures as Client\n",
    "import plotly.graph_objects as go\n",
    "from plotly.subplots import make_subplots\n",
    "from fitter import Fitter, get_common_distributions, get_distributions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "d13d47b8-cbe0-49c9-8259-c884ae46a560",
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "import numpy as np\n",
    "from prophet.diagnostics import cross_validation\n",
    "from prophet.diagnostics import performance_metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "c9553bff-0edf-412f-b0cb-9f2abe40cf21",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "39e9142c-e2cd-47b2-8680-556148d52976",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torchmetrics\n",
    "from torchmetrics import MetricCollection, Accuracy, Specificity, Precision, Recall, AUROC, F1Score\n",
    "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay, roc_curve, RocCurveDisplay\n",
    "from sklearn.model_selection import train_test_split\n",
    "from torchvision import models, transforms\n",
    "from torchsummary import summary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "6438fc8d-b1b5-491d-b3a3-1e3761b4da9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import ta\n",
    "import arff"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "f4fa04bd-e1b8-42d2-9964-178b0dc76ff4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.nn.functional as F\n",
    "\n",
    "from sklearn.preprocessing import StandardScaler    \n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.metrics import confusion_matrix, classification_report\n",
    "\n",
    "from torchvision import datasets, models, transforms\n",
    "from torchinfo import summary\n",
    "from torch.utils.tensorboard import SummaryWriter\n",
    "\n",
    "import optuna"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1e85fa77-6848-428c-a25d-de941ca58bee",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "futures_client = Client()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b86e866-add0-4142-89f7-b91b22a33283",
   "metadata": {},
   "source": [
    "## price data import"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "13dfc182-32de-481a-973f-780acc3d742c",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "collumns2 = [\n",
    "'Open time',\n",
    "'Open',\n",
    "'High',\n",
    "'Low',\n",
    "'Close',\n",
    "'Volume',\n",
    "'Close time',\n",
    "'Quote asset volume',\n",
    "'Number of trades',\n",
    "'Taker buy base asset volume',\n",
    "'Taker buy quote asset volume',\n",
    "'Ignore'\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "52cbc991-cf3d-4af7-b6aa-216db3e93971",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "def to_df(data_as_array):\n",
    "    df=pd.DataFrame(data_as_array, columns = collumns2)\n",
    "    df['Open time'] = df.apply(lambda x: datetime.fromtimestamp(int(x['Open time'])/1000) , axis=1)\n",
    "    df['Close time'] = df.apply(lambda x: datetime.fromtimestamp(int(x['Close time'])/1000) , axis=1)\n",
    "    df.drop(columns = ['Close time', 'Quote asset volume', 'Number of trades', 'Taker buy base asset volume', 'Taker buy quote asset volume', 'Ignore'], inplace = True)\n",
    "    df[['Open', 'High', 'Low', 'Close', 'Volume']] = df[['Open', 'High', 'Low', 'Close', 'Volume']].astype('float32', copy=False)\n",
    "    return df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "af051627-94d3-4ad9-b971-a2f6b0ba8125",
   "metadata": {},
   "outputs": [],
   "source": [
    "data_1d = futures_client.klines(\"BTCUSDT\", \"1d\", **{\"limit\": 1500})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "67bf7276-3cab-4ae9-89e7-95750e8d0ac8",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = to_df(data_1d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "2f85a659-7e08-469c-909e-30d21289327e",
   "metadata": {
    "tags": []
   },
   "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>Open time</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2019-09-07 20:00:00</td>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10412.650391</td>\n",
       "      <td>10000.000000</td>\n",
       "      <td>10391.629883</td>\n",
       "      <td>3096.291016</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2019-09-08 20:00:00</td>\n",
       "      <td>10316.620117</td>\n",
       "      <td>10475.540039</td>\n",
       "      <td>10077.219727</td>\n",
       "      <td>10307.000000</td>\n",
       "      <td>14824.373047</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2019-09-09 20:00:00</td>\n",
       "      <td>10307.000000</td>\n",
       "      <td>10382.969727</td>\n",
       "      <td>9940.870117</td>\n",
       "      <td>10102.019531</td>\n",
       "      <td>9068.955078</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2019-09-10 20:00:00</td>\n",
       "      <td>10094.269531</td>\n",
       "      <td>10293.110352</td>\n",
       "      <td>9884.309570</td>\n",
       "      <td>10159.549805</td>\n",
       "      <td>10897.921875</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2019-09-11 20:00:00</td>\n",
       "      <td>10163.059570</td>\n",
       "      <td>10450.129883</td>\n",
       "      <td>10042.120117</td>\n",
       "      <td>10415.129883</td>\n",
       "      <td>15609.633789</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "            Open time          Open          High           Low         Close  \\\n",
       "0 2019-09-07 20:00:00  10000.000000  10412.650391  10000.000000  10391.629883   \n",
       "1 2019-09-08 20:00:00  10316.620117  10475.540039  10077.219727  10307.000000   \n",
       "2 2019-09-09 20:00:00  10307.000000  10382.969727   9940.870117  10102.019531   \n",
       "3 2019-09-10 20:00:00  10094.269531  10293.110352   9884.309570  10159.549805   \n",
       "4 2019-09-11 20:00:00  10163.059570  10450.129883  10042.120117  10415.129883   \n",
       "\n",
       "         Volume  \n",
       "0   3096.291016  \n",
       "1  14824.373047  \n",
       "2   9068.955078  \n",
       "3  10897.921875  \n",
       "4  15609.633789  "
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54397854-7d15-48ea-9a70-347b5c01db14",
   "metadata": {},
   "source": [
    "## indicators calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "3bb021a7-9b4f-4d4a-8131-7125224e538c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bakhi\\anaconda3\\lib\\site-packages\\ta\\trend.py:769: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  dip[idx] = 100 * (self._dip[idx] / value)\n",
      "C:\\Users\\bakhi\\anaconda3\\lib\\site-packages\\ta\\trend.py:774: RuntimeWarning: invalid value encountered in double_scalars\n",
      "  din[idx] = 100 * (self._din[idx] / value)\n"
     ]
    }
   ],
   "source": [
    "df_RSI_ADX = indi_calc(df).RSI_ADX(14,20)\n",
    "df = df_RSI_ADX"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e31d21a3-999b-4710-9a60-29fe2cefaa38",
   "metadata": {},
   "source": [
    "## volume change calculation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "67bdaf66-07de-4fa3-bdee-4e818c279540",
   "metadata": {},
   "outputs": [],
   "source": [
    "# multiplicator = 0.2\n",
    "percent_vol = []\n",
    "cum_volume_step = 7\n",
    "i = 0\n",
    "for v in df.Volume:\n",
    "    if cum_volume_step > i:\n",
    "        percent_vol.append(np.nan)\n",
    "    else:\n",
    "        percent_vol.append(100*v/df.Volume[i-cum_volume_step:i].sum())\n",
    "    i+=1\n",
    "df['Vol_week'] = percent_vol"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1fc9ad68-5426-4bf2-a973-b51a55c7904f",
   "metadata": {},
   "source": [
    "## present price changing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "b14a67a5-f4f7-496c-94eb-87afbd968f27",
   "metadata": {},
   "outputs": [],
   "source": [
    "present_price = []\n",
    "cum_volume_step = 7\n",
    "i = 0\n",
    "for v in df.Open:\n",
    "    if cum_volume_step > i:\n",
    "        present_price.append(np.nan)\n",
    "    else:\n",
    "        present_price.append((v - df.Open[i-cum_volume_step])/df.Open[i-cum_volume_step])\n",
    "    i+=1\n",
    "df['last_week'] = present_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "e79a0ab2-4875-483a-9b78-b981b3060cd3",
   "metadata": {},
   "outputs": [],
   "source": [
    "present_price = []\n",
    "cum_volume_step = 30\n",
    "i = 0\n",
    "for v in df.Open:\n",
    "    if cum_volume_step > i:\n",
    "        present_price.append(np.nan)\n",
    "    else:\n",
    "        present_price.append((v - df.Open[i-cum_volume_step])/df.Open[i-cum_volume_step])\n",
    "    i+=1\n",
    "df['last_month'] = present_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "f9bd0da4-3888-4030-8e97-8564814f5620",
   "metadata": {},
   "outputs": [],
   "source": [
    "present_price = []\n",
    "cum_volume_step = 1\n",
    "i = 0\n",
    "for v in df.Open:\n",
    "    if cum_volume_step > i:\n",
    "        present_price.append(np.nan)\n",
    "    else:\n",
    "        present_price.append((df.Close[i-cum_volume_step] - df.Open[i-cum_volume_step])/df.Open[i-cum_volume_step])\n",
    "    i+=1\n",
    "df['yesterday'] = present_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cf0ec68f-5960-4cba-9c1d-ecc4b9770f97",
   "metadata": {},
   "outputs": [],
   "source": [
    "present_price = []\n",
    "cum_volume_step = 1\n",
    "i = 0\n",
    "for v in df.RSI:\n",
    "    if i<1:\n",
    "        present_price.append(np.nan)\n",
    "    else:\n",
    "        present_price.append((v - df.RSI[i-cum_volume_step])/df.RSI[i-cum_volume_step])\n",
    "    i+=1\n",
    "df['RSI_gap'] = present_price"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf467896-a482-4b59-aa10-cde52bb6b57e",
   "metadata": {},
   "source": [
    "## future price change"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "1a3a2259-dfcc-4d5f-8658-a68527308629",
   "metadata": {},
   "outputs": [],
   "source": [
    "future_price = []\n",
    "lengh = len(df.Open)\n",
    "i = 0\n",
    "for v in range(lengh):\n",
    "    aver_future_price = (df.Close[i]-df.Open[i])/df.Open[i]\n",
    "    future_price.append(100*aver_future_price)\n",
    "    i+=1\n",
    "df['target'] = future_price"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "0b9d9858-0448-4c9d-944b-cdeec171ec18",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df.target.hist(bins=75)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "d65f200c-4eb6-436a-86dc-b60b27108ee6",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df[['ADX', '-DI', '+DI', 'RSI', 'Vol_week', 'last_week', 'last_month', 'yesterday', 'RSI_gap','target']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "226a063a-c8f7-4bbd-84c3-b3775e974ea9",
   "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>ADX</th>\n",
       "      <th>-DI</th>\n",
       "      <th>+DI</th>\n",
       "      <th>RSI</th>\n",
       "      <th>Vol_week</th>\n",
       "      <th>last_week</th>\n",
       "      <th>last_month</th>\n",
       "      <th>yesterday</th>\n",
       "      <th>RSI_gap</th>\n",
       "      <th>target</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>3.916299</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.039163</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.093249</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.000932</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-1.988750</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>-0.019888</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.646706</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>NaN</td>\n",
       "      <td>0.006467</td>\n",
       "      <td>NaN</td>\n",
       "      <td>2.480260</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   ADX  -DI  +DI  RSI  Vol_week  last_week  last_month  yesterday  RSI_gap  \\\n",
       "0  0.0  0.0  0.0  NaN       NaN        NaN         NaN        NaN      NaN   \n",
       "1  0.0  0.0  0.0  NaN       NaN        NaN         NaN   0.039163      NaN   \n",
       "2  0.0  0.0  0.0  NaN       NaN        NaN         NaN  -0.000932      NaN   \n",
       "3  0.0  0.0  0.0  NaN       NaN        NaN         NaN  -0.019888      NaN   \n",
       "4  0.0  0.0  0.0  NaN       NaN        NaN         NaN   0.006467      NaN   \n",
       "\n",
       "     target  \n",
       "0  3.916299  \n",
       "1 -0.093249  \n",
       "2 -1.988750  \n",
       "3  0.646706  \n",
       "4  2.480260  "
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "295e764a-6c45-438e-b9e0-802204094e1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df.to_csv('BTC_daily2.csv', index = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "0d530f79-ca4f-400b-a3d8-23e43a4849f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "#df = pd.read_csv('BTC_daily.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "74e3fdf8-1851-4c1e-aee1-c402c5241600",
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.dropna()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "026b4c51-2644-4ca8-b7c9-57dd9ce9cecc",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-53-a5fbeb98518e>:1: 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",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['target'] = df['target'].apply(lambda x: 1 if x>=0 else 0)\n"
     ]
    }
   ],
   "source": [
    "df['target'] = df['target'].apply(lambda x: 1 if x>=0 else 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "e5a7f03a-8467-4278-9b70-d83acfbbceda",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-57-2226efc13b9c>:1: 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",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['target'] = df['target'].astype('category')\n"
     ]
    }
   ],
   "source": [
    "df['target'] = df['target'].astype('category')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "644ec320-7cf2-43ef-89d7-6853851be204",
   "metadata": {},
   "source": [
    "# simple NN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "7c0d045f-3ccd-42cb-a3bd-6c06453042aa",
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def train(dataloader, model, loss, optimizer, t):\n",
    "    \n",
    "    model.train()\n",
    "    size = len(dataloader.dataset)\n",
    "    \n",
    "    for X_batch, y_batch in train_loader:\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        y_pred = model(X_batch)\n",
    "        \n",
    "        loss = criterion(y_pred, y_batch.unsqueeze(1))\n",
    "        \n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        loss += loss.item()\n",
    "        \n",
    "    writer.add_scalar('Loss/train', loss, t)\n",
    "    \n",
    "def test(dataloader, model,t):\n",
    "    \n",
    "    size = len(dataloader.dataset)\n",
    "    model.eval()\n",
    "    test_loss, correct = 0, 0\n",
    "    \n",
    "    # initialize metric\n",
    "    test_metric_collection = MetricCollection([\n",
    "    Accuracy(),\n",
    "    AUROC(),\n",
    "    Recall(),\n",
    "    Precision(),\n",
    "    F1Score()\n",
    "    ]).to(device)\n",
    "    \n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for X_batch, y_batch in valid_loader:\n",
    "            X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "            \n",
    "            y_test_pred = model(X_batch)\n",
    "            y_test_pred = torch.sigmoid(y_test_pred)\n",
    "            test_loss += criterion(y_test_pred, y_batch.unsqueeze(1)).item()\n",
    "            y_batch = y_batch.type(torch.int)\n",
    "            prediction = y_test_pred.T[0]\n",
    "            test_metric_collection(prediction, y_batch)\n",
    "    test_loss /= size\n",
    "    total_metric_collection = test_metric_collection.compute()\n",
    "    \n",
    "    writer.add_scalar('Loss/test', test_loss, t)\n",
    "    writer.add_scalar('Accuracy/test', total_metric_collection['Accuracy'], t)\n",
    "    writer.add_scalar('AUROC/test', total_metric_collection['AUROC'], t)\n",
    "    writer.add_scalar('Sensitivity/test', total_metric_collection['Recall'], t)\n",
    "    writer.add_scalar('Precision/test', total_metric_collection['Precision'], t)\n",
    "    writer.add_scalar('F1/test', total_metric_collection['F1Score'], t)\n",
    "    \n",
    "    test_metric_collection.reset()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "3399f65d-85c9-4b25-af18-2a66fc76a424",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<ipython-input-57-2226efc13b9c>:1: 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",
      "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n",
      "  df['target'] = df['target'].astype('category')\n"
     ]
    }
   ],
   "source": [
    "df['target'] = df['target'].astype('category')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "31d56669-2a47-4117-b190-4d4e10a40b19",
   "metadata": {},
   "outputs": [],
   "source": [
    "X = df.iloc[:, 0:-1]\n",
    "y = df.iloc[:, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "ddbe6717-f933-47b5-a8c0-d2b561867545",
   "metadata": {},
   "outputs": [],
   "source": [
    "lenght_train = int(len(df)*0.7)\n",
    "lenght_valid = int(len(df)*0.04)\n",
    "lenght_test = len(df) - lenght_train - lenght_valid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "id": "3d98e06f-8780-43c7-ab77-54c80a7141dc",
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train = X[:lenght_train]\n",
    "X_valid = X[lenght_train : lenght_train + lenght_valid]\n",
    "X_test = X[-lenght_test:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "27942f02-b078-4685-ab4e-cf5a12312626",
   "metadata": {},
   "outputs": [],
   "source": [
    "y_train = y[:lenght_train]\n",
    "y_valid = y[lenght_train : lenght_train + lenght_valid]\n",
    "y_test = y[-lenght_test:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "3c079f63-f17e-482e-acf9-5f312158cf9a",
   "metadata": {},
   "outputs": [],
   "source": [
    "scaler = StandardScaler()\n",
    "X_train = scaler.fit_transform(X_train)\n",
    "X_valid = scaler.transform(X_valid)\n",
    "X_test = scaler.transform(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "aa5f5bef-86db-4c45-b43a-d43cc757b1ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "EPOCHS = 50\n",
    "BATCH_SIZE = 64\n",
    "LEARNING_RATE = 0.001"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "6af505d6-afe7-470d-a562-2ebc10004814",
   "metadata": {},
   "outputs": [],
   "source": [
    "## train data\n",
    "class TrainData(Dataset):\n",
    "    \n",
    "    def __init__(self, X_data, y_data):\n",
    "        self.X_data = X_data\n",
    "        self.y_data = y_data\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        return self.X_data[index], self.y_data[index]\n",
    "        \n",
    "    def __len__ (self):\n",
    "        return len(self.X_data)\n",
    "\n",
    "\n",
    "train_data = TrainData(torch.FloatTensor(X_train), \n",
    "                       torch.FloatTensor(y_train.values))\n",
    "\n",
    "## train data\n",
    "class ValidData(Dataset):\n",
    "    \n",
    "    def __init__(self, X_data, y_data):\n",
    "        self.X_data = X_data\n",
    "        self.y_data = y_data\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        return self.X_data[index], self.y_data[index]\n",
    "        \n",
    "    def __len__ (self):\n",
    "        return len(self.X_data)\n",
    "\n",
    "\n",
    "valid_data = ValidData(torch.FloatTensor(X_valid), \n",
    "                       torch.FloatTensor(y_valid.values))\n",
    "\n",
    "## test data    \n",
    "class TestData(Dataset):\n",
    "    \n",
    "    def __init__(self, X_data, y_data):\n",
    "        self.X_data = X_data\n",
    "        self.y_data = y_data\n",
    "        \n",
    "    def __getitem__(self, index):\n",
    "        return self.X_data[index], self.y_data[index]\n",
    "        \n",
    "    def __len__ (self):\n",
    "        return len(self.X_data)\n",
    "    \n",
    "\n",
    "test_data = TestData(torch.FloatTensor(X_test), \n",
    "                     torch.FloatTensor(y_test.values))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "57c98b83-c470-45f9-b118-75584d40db73",
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(dataset=train_data, batch_size=BATCH_SIZE, shuffle=True)\n",
    "valid_loader = DataLoader(dataset=valid_data, batch_size=BATCH_SIZE, shuffle=True)\n",
    "test_loader = DataLoader(dataset=test_data, batch_size=BATCH_SIZE, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41822e42-08f1-4a5a-a671-e71e6988211a",
   "metadata": {},
   "source": [
    "## model 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "214f1dff-4926-46fe-a861-e4f1c90c74c0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BTC_100(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(BTC_100, self).__init__()\n",
    "        # Number of input features is 12.\n",
    "        self.layer_1 = nn.Linear(9, 16) \n",
    "        self.layer_2 = nn.Linear(16, 8)\n",
    "        self.layer_3 = nn.Linear(8, 4)\n",
    "        self.layer_out = nn.Linear(4, 1)\n",
    "        \n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(p=0.1)\n",
    "        self.batchnorm1 = nn.BatchNorm1d(16)\n",
    "        self.batchnorm2 = nn.BatchNorm1d(8)\n",
    "        self.batchnorm3 = nn.BatchNorm1d(4)\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        x = self.relu(self.layer_1(inputs))\n",
    "        x = self.batchnorm1(x)\n",
    "        \n",
    "        x = self.relu(self.layer_2(x))\n",
    "        x = self.batchnorm2(x)\n",
    "        \n",
    "        x = self.relu(self.layer_3(x))\n",
    "        x = self.batchnorm3(x)\n",
    "        \n",
    "        x = self.dropout(x)\n",
    "        x = self.layer_out(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "f4c0e60b-2b86-4d49-80ba-222ff814f0bb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "fa4545aa-f820-41f8-b8b8-2354804074a3",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bakhi\\anaconda3\\lib\\site-packages\\torchmetrics\\utilities\\prints.py:36: UserWarning: Metric `AUROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
      "  warnings.warn(*args, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model = BTC_100()\n",
    "model.to(device)\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "epochs = 500\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "writer = SummaryWriter(log_dir = 'runs/' + str(model).split('(')[0])\n",
    "\n",
    "for t in range(epochs):\n",
    "    train(train_loader, model, criterion, optimizer, t)\n",
    "    test(valid_loader, model, t)\n",
    "    torch.save(model.state_dict(), 'models/' + str(model).split('(')[0] + '_tvt_' + str(t) + '.pt')\n",
    "\n",
    "writer.close()\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "id": "bd0e7daa-e238-48f4-817c-d23d3168d85c",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recall : 0.7307692307692307\n",
      "precision : 0.6495726495726496\n",
      "F1 : 0.6877828054298643\n",
      "acc : 0.6634146341463415\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.roc_curve.RocCurveDisplay at 0x1435591dc40>"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = BTC_100()\n",
    "model_name = 'models/' + str(model).split('(')[0] + '_tvt_' + str(495) + '.pt'\n",
    "state_dict = torch.load(model_name)\n",
    "model.load_state_dict(state_dict)\n",
    "\n",
    "\n",
    "y_pred_list_rounded = []\n",
    "y_pred_list = []\n",
    "targets = []\n",
    "\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in valid_loader:\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "        targets.append(y_batch)\n",
    "\n",
    "        y_test_pred = model(X_batch)\n",
    "        y_test_pred = torch.sigmoid(y_test_pred)\n",
    "        y_pred_tag = torch.round(y_test_pred)\n",
    "        y_pred_list_rounded.append(y_pred_tag.cpu().numpy())\n",
    "        y_pred_list.append(y_test_pred.cpu().numpy())\n",
    "\n",
    "y_pred_list_rounded = [a.squeeze().tolist() for a in y_pred_list_rounded]\n",
    "y_pred_list = [a.squeeze().tolist() for a in y_pred_list]\n",
    "targets = [a.squeeze().tolist() for a in targets]\n",
    "\n",
    "\n",
    "y_pred_list_rounded = [j for sub in y_pred_list_rounded for j in sub]\n",
    "y_pred_list = [j for sub in y_pred_list for j in sub]\n",
    "targets = [j for sub in targets for j in sub]\n",
    "\n",
    "cm = confusion_matrix(targets, y_pred_list_rounded)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['0', '1'])\n",
    "disp.plot()\n",
    "TP, FP, TN, FN = cm[1,1], cm[0,1], cm[0,0], cm[1,0]\n",
    "P = TP/(TP+FP)\n",
    "R = TP/(TP+FN)\n",
    "F1 = 2*P*R/(P+R)\n",
    "print(f'recall : {R}')\n",
    "print(f'precision : {P}')\n",
    "print(f'F1 : {F1}')\n",
    "print(f'acc : {(TP + TN)/(TP + TN + FP + FN)}')\n",
    "RocCurveDisplay.from_predictions(targets, y_pred_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "543d0598-0e0e-4fae-a961-143350999002",
   "metadata": {},
   "source": [
    "## model 101 reduced valid data set = 100 days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "c50938c9-6e62-43c7-959e-9ed60fd72d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BTC_101(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(BTC_101, self).__init__()\n",
    "        # Number of input features is 12.\n",
    "        self.layer_1 = nn.Linear(9, 16) \n",
    "        self.layer_2 = nn.Linear(16, 8)\n",
    "        self.layer_3 = nn.Linear(8, 4)\n",
    "        self.layer_out = nn.Linear(4, 1)\n",
    "        \n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(p=0.1)\n",
    "        self.batchnorm1 = nn.BatchNorm1d(16)\n",
    "        self.batchnorm2 = nn.BatchNorm1d(8)\n",
    "        self.batchnorm3 = nn.BatchNorm1d(4)\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        x = self.relu(self.layer_1(inputs))\n",
    "        x = self.batchnorm1(x)\n",
    "        \n",
    "        x = self.relu(self.layer_2(x))\n",
    "        x = self.batchnorm2(x)\n",
    "        \n",
    "        x = self.relu(self.layer_3(x))\n",
    "        x = self.batchnorm3(x)\n",
    "        \n",
    "        x = self.dropout(x)\n",
    "        x = self.layer_out(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "82c59b6c-75bd-46d6-bb16-f39b8008f6f9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "6d4abc60-0163-4d69-8427-9319279aa364",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bakhi\\anaconda3\\lib\\site-packages\\torchmetrics\\utilities\\prints.py:36: UserWarning: Metric `AUROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
      "  warnings.warn(*args, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model = BTC_101()\n",
    "model.to(device)\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "epochs = 500\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "writer = SummaryWriter(log_dir = 'runs/' + str(model).split('(')[0])\n",
    "\n",
    "for t in range(epochs):\n",
    "    train(train_loader, model, criterion, optimizer, t)\n",
    "    test(valid_loader, model, t)\n",
    "    torch.save(model.state_dict(), 'models/' + str(model).split('(')[0] + '_tvt_' + str(t) + '.pt')\n",
    "\n",
    "writer.close()\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "b044a44b-1e4d-4b24-97cb-8639305880b2",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recall : 0.673469387755102\n",
      "precision : 0.6875\n",
      "F1 : 0.6804123711340205\n",
      "acc : 0.696078431372549\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.roc_curve.RocCurveDisplay at 0x1435d2f0eb0>"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = BTC_101()\n",
    "model_name = 'models/' + str(model).split('(')[0] + '_tvt_' + str(495) + '.pt'\n",
    "state_dict = torch.load(model_name)\n",
    "model.load_state_dict(state_dict)\n",
    "\n",
    "\n",
    "y_pred_list_rounded = []\n",
    "y_pred_list = []\n",
    "targets = []\n",
    "\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in valid_loader:\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "        targets.append(y_batch)\n",
    "\n",
    "        y_test_pred = model(X_batch)\n",
    "        y_test_pred = torch.sigmoid(y_test_pred)\n",
    "        y_pred_tag = torch.round(y_test_pred)\n",
    "        y_pred_list_rounded.append(y_pred_tag.cpu().numpy())\n",
    "        y_pred_list.append(y_test_pred.cpu().numpy())\n",
    "\n",
    "y_pred_list_rounded = [a.squeeze().tolist() for a in y_pred_list_rounded]\n",
    "y_pred_list = [a.squeeze().tolist() for a in y_pred_list]\n",
    "targets = [a.squeeze().tolist() for a in targets]\n",
    "\n",
    "\n",
    "y_pred_list_rounded = [j for sub in y_pred_list_rounded for j in sub]\n",
    "y_pred_list = [j for sub in y_pred_list for j in sub]\n",
    "targets = [j for sub in targets for j in sub]\n",
    "\n",
    "cm = confusion_matrix(targets, y_pred_list_rounded)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['0', '1'])\n",
    "disp.plot()\n",
    "TP, FP, TN, FN = cm[1,1], cm[0,1], cm[0,0], cm[1,0]\n",
    "P = TP/(TP+FP)\n",
    "R = TP/(TP+FN)\n",
    "F1 = 2*P*R/(P+R)\n",
    "print(f'recall : {R}')\n",
    "print(f'precision : {P}')\n",
    "print(f'F1 : {F1}')\n",
    "print(f'acc : {(TP + TN)/(TP + TN + FP + FN)}')\n",
    "RocCurveDisplay.from_predictions(targets, y_pred_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "316e0a0d-5e40-48c8-a2eb-d0b7bd4b496c",
   "metadata": {},
   "source": [
    "## model 102 reduced valid data set = 30 days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "1c731634-8f12-4d5d-99e8-f1782a803783",
   "metadata": {},
   "outputs": [],
   "source": [
    "class BTC_102(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(BTC_102, self).__init__()\n",
    "        # Number of input features is 12.\n",
    "        self.layer_1 = nn.Linear(9, 16) \n",
    "        self.layer_2 = nn.Linear(16, 8)\n",
    "        self.layer_3 = nn.Linear(8, 4)\n",
    "        self.layer_out = nn.Linear(4, 1)\n",
    "        \n",
    "        self.relu = nn.ReLU()\n",
    "        self.dropout = nn.Dropout(p=0.1)\n",
    "        self.batchnorm1 = nn.BatchNorm1d(16)\n",
    "        self.batchnorm2 = nn.BatchNorm1d(8)\n",
    "        self.batchnorm3 = nn.BatchNorm1d(4)\n",
    "        \n",
    "    def forward(self, inputs):\n",
    "        x = self.relu(self.layer_1(inputs))\n",
    "        x = self.batchnorm1(x)\n",
    "        \n",
    "        x = self.relu(self.layer_2(x))\n",
    "        x = self.batchnorm2(x)\n",
    "        \n",
    "        x = self.relu(self.layer_3(x))\n",
    "        x = self.batchnorm3(x)\n",
    "        \n",
    "        x = self.dropout(x)\n",
    "        x = self.layer_out(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "2b8019b9-4b6f-477b-a1e8-9703682ccd27",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cpu\")\n",
    "print(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "id": "f31e1811-e8d7-40e2-afad-e69d7f019fe0",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\bakhi\\anaconda3\\lib\\site-packages\\torchmetrics\\utilities\\prints.py:36: UserWarning: Metric `AUROC` will save all targets and predictions in buffer. For large datasets this may lead to large memory footprint.\n",
      "  warnings.warn(*args, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "model = BTC_102()\n",
    "model.to(device)\n",
    "criterion = nn.BCEWithLogitsLoss()\n",
    "\n",
    "epochs = 500\n",
    "\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.0001)\n",
    "writer = SummaryWriter(log_dir = 'runs/' + str(model).split('(')[0])\n",
    "\n",
    "for t in range(epochs):\n",
    "    train(train_loader, model, criterion, optimizer, t)\n",
    "    test(valid_loader, model, t)\n",
    "    torch.save(model.state_dict(), 'models/' + str(model).split('(')[0] + '_tvt_' + str(t) + '.pt')\n",
    "\n",
    "writer.close()\n",
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "c776671a-7c39-45dd-8f4e-af8916528029",
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "recall : 0.5\n",
      "precision : 0.8461538461538461\n",
      "F1 : 0.6285714285714286\n",
      "acc : 0.6829268292682927\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<sklearn.metrics._plot.roc_curve.RocCurveDisplay at 0x1435d4f2be0>"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "model = BTC_102()\n",
    "model_name = 'models/' + str(model).split('(')[0] + '_tvt_' + str(495) + '.pt'\n",
    "state_dict = torch.load(model_name)\n",
    "model.load_state_dict(state_dict)\n",
    "\n",
    "\n",
    "y_pred_list_rounded = []\n",
    "y_pred_list = []\n",
    "targets = []\n",
    "\n",
    "\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for X_batch, y_batch in valid_loader:\n",
    "        X_batch, y_batch = X_batch.to(device), y_batch.to(device)\n",
    "        targets.append(y_batch)\n",
    "\n",
    "        y_test_pred = model(X_batch)\n",
    "        y_test_pred = torch.sigmoid(y_test_pred)\n",
    "        y_pred_tag = torch.round(y_test_pred)\n",
    "        y_pred_list_rounded.append(y_pred_tag.cpu().numpy())\n",
    "        y_pred_list.append(y_test_pred.cpu().numpy())\n",
    "\n",
    "y_pred_list_rounded = [a.squeeze().tolist() for a in y_pred_list_rounded]\n",
    "y_pred_list = [a.squeeze().tolist() for a in y_pred_list]\n",
    "targets = [a.squeeze().tolist() for a in targets]\n",
    "\n",
    "\n",
    "y_pred_list_rounded = [j for sub in y_pred_list_rounded for j in sub]\n",
    "y_pred_list = [j for sub in y_pred_list for j in sub]\n",
    "targets = [j for sub in targets for j in sub]\n",
    "\n",
    "cm = confusion_matrix(targets, y_pred_list_rounded)\n",
    "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['0', '1'])\n",
    "disp.plot()\n",
    "TP, FP, TN, FN = cm[1,1], cm[0,1], cm[0,0], cm[1,0]\n",
    "P = TP/(TP+FP)\n",
    "R = TP/(TP+FN)\n",
    "F1 = 2*P*R/(P+R)\n",
    "print(f'recall : {R}')\n",
    "print(f'precision : {P}')\n",
    "print(f'F1 : {F1}')\n",
    "print(f'acc : {(TP + TN)/(TP + TN + FP + FN)}')\n",
    "RocCurveDisplay.from_predictions(targets, y_pred_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b2e93aa6-a919-42e4-aef5-27d9280ea872",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}