fin_rl_qlearning_v2.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nwaAZRu1NTiI"
      },
      "source": [
        "# Q-learning \n",
        "\n",
        "#### This version implements q-learning using a custom enviroment on a 4h tick ETHUSDT\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "DDf1gLC2NTiK"
      },
      "outputs": [],
      "source": [
        "# !pip install -r ./requirements.txt\n",
        "!pip install stable_baselines3[extra]\n",
        "!pip install yfinance\n",
        "!pip install talib-binary\n",
        "!pip install huggingface_sb3\n",
        "!pip install binance_historical_data\n",
        "!mkdir ./data\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 36,
      "metadata": {
        "id": "LNXxxKojNTiL"
      },
      "outputs": [],
      "source": [
        "import gym\n",
        "from gym import spaces\n",
        "from gym.utils import seeding\n",
        "\n",
        "import talib as ta\n",
        "from tqdm.notebook import tqdm\n",
        "\n",
        "import yfinance as yf\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "from matplotlib import pyplot as plt\n",
        "from binance_historical_data import BinanceDataDumper\n",
        "import glob\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 79,
      "metadata": {
        "id": "dmAuEhZZNTiL"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Choose tickers to dump:\n",
            "---> Found overall tickers: 2137\n",
            "---> Filter to asked tickers: 1\n",
            "------> Tickers left: 1\n",
            "---> Exclude asked tickers: 1\n",
            "------> Tickers left: 1\n",
            "Download full data for 1 tickers: \n",
            "---> Data Frequency: 4h\n",
            "---> Start Date: 20170101\n",
            "---> End Date: 20221217\n"
          ]
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "9a01a9e1a2ec4ad6acc88d66f23de10b",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "Tickers:   0%|          | 0/1 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "033d2caff10146688faa327e86814931",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "monthly files to download:   0%|          | 0/7 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "869e4c63806c498683e0da2bebb8a432",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "daily files to download: 0it [00:00, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Tried to dump data for 1 tickers:\n",
            "---> For ETHUSDT new data saved for: 0 months 0 days\n"
          ]
        }
      ],
      "source": [
        "# Get data\n",
        "data_dumper = BinanceDataDumper(\n",
        "    path_dir_where_to_dump=\"./data\",\n",
        "    data_type=\"klines\",  # aggTrades, klines, trades\n",
        "    data_frequency=\"4h\",  # argument for data_type=\"klines\"\n",
        ")\n",
        "data_dumper.dump_data(\n",
        "    tickers=['ETHUSDT'],\n",
        "    date_start=None,\n",
        "    date_end=None,\n",
        "    is_to_update_existing=False,\n",
        "    tickers_to_exclude=[\"UST\"],\n",
        ")\n",
        "\n",
        "def get_df():\n",
        "    df_arr = []\n",
        "    for f in glob.glob('./data/spot/monthly/klines/ETHUSDT/4h/*.csv'):\n",
        "        df= pd.read_csv(f)\n",
        "        df.columns = ['datetime', 'Open', 'High', 'Low', 'Close', 'Volume','close_time', 'qav', 'num_trades','taker_base_vol', 'taker_quote_vol', 'ignore'] \n",
        "        df['datetime'] = df['datetime'].div(1000)\n",
        "        df['datetime'] = pd.to_datetime(df['datetime'],unit='s')\n",
        "        df.set_index('datetime', inplace=True)\n",
        "        df = df.drop(['qav','taker_base_vol','taker_quote_vol','ignore','close_time'],axis=1)\n",
        "        df_arr.append(df)\n",
        "\n",
        "    df_f = pd.concat(df_arr,axis=0)\n",
        "    df_f = df_f.replace(np.inf, np.nan)\n",
        "    df_f = df_f.dropna()\n",
        "    return pd.concat(df_arr,axis=0)\n",
        "df = get_df()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 116,
      "metadata": {},
      "outputs": [],
      "source": [
        "eth_train = df[0:-500]\n",
        "eth_test = df[-500:]\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 46,
      "metadata": {},
      "outputs": [],
      "source": [
        "def initialize_q_table(state_space, action_space):\n",
        "  Qtable = np.zeros((state_space, action_space))\n",
        "  return Qtable"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Policy\n",
        "\n",
        "def greedy_policy(Qtable, state):\n",
        "    # Exploitation: take the action with the highest state, action value\n",
        "    # if we dont have a state return DO_NOTHING \n",
        "    if abs(np.max(Qtable[state])) > 0:\n",
        "        action = np.argmax(Qtable[state])\n",
        "    else:\n",
        "        action = 2\n",
        "  \n",
        "    return action\n",
        "\n",
        "\n",
        "def epsilon_greedy_policy(Qtable, state, epsilon, env):\n",
        "  # Randomly generate a number between 0 and 1\n",
        "  random_num = np.random.uniform(size=1)\n",
        "  # if random_num > greater than epsilon --> exploitation\n",
        "  if random_num > epsilon:\n",
        "    # Take the action with the highest value given a state\n",
        "    # np.argmax can be useful here\n",
        "    action = greedy_policy(Qtable, state)\n",
        "  # else --> exploration\n",
        "  else:\n",
        "    # action = np.random.random_integers(4,size=1)[0]\n",
        "    action = env.action_space.sample()\n",
        "  \n",
        "  return action"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 48,
      "metadata": {
        "id": "wlC-EdLENTiN"
      },
      "outputs": [],
      "source": [
        "def train(n_training_episodes, min_epsilon, max_epsilon, decay_rate, env, max_steps, Qtable, learning_rate, gamma):\n",
        "  state_history = []\n",
        "  \n",
        "  for episode in range(n_training_episodes):\n",
        "    # Reduce epsilon (because we need less and less exploration)\n",
        "    epsilon = min_epsilon + (max_epsilon - min_epsilon)*np.exp(-decay_rate*episode)\n",
        "    # Reset the environment\n",
        "    state = env.reset()\n",
        "    step = 0\n",
        "    done = False\n",
        "\n",
        "    # repeat\n",
        "    for step in range(max_steps):\n",
        "      # Choose the action At using epsilon greedy policy\n",
        "      action = epsilon_greedy_policy(Qtable, state, epsilon, env)\n",
        "\n",
        "      # Take action At and observe Rt+1 and St+1\n",
        "      # Take the action (a) and observe the outcome state(s') and reward (r)\n",
        "      new_state, reward, done, info = env.step(action)\n",
        "\n",
        "      # Update Q(s,a):= Q(s,a) + lr [R(s,a) + gamma * max Q(s',a') - Q(s,a)]\n",
        "      Qtable[state][action] = Qtable[state][action] + learning_rate * (reward + gamma * ( np.max(Qtable[new_state])  ) -  Qtable[state][action] )\n",
        "\n",
        "      # If done, finish the episode\n",
        "      if done:\n",
        "        break\n",
        "      \n",
        "      # Our next state is the new state\n",
        "      state = new_state\n",
        "\n",
        "      state_history.append(state)  \n",
        "\n",
        "  return Qtable, state_history"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 99,
      "metadata": {},
      "outputs": [],
      "source": [
        "from enum import Enum\n",
        "class Actions(Enum):\n",
        "    Sell = 0\n",
        "    Buy = 1\n",
        "    Do_nothing = 2\n",
        "\n",
        "class CustTradingEnv(gym.Env):\n",
        "    metadata = {'render.modes': ['human']}\n",
        "\n",
        "    def __init__(self, df, max_steps=0):\n",
        "        self.seed()\n",
        "        self.df = df\n",
        "        self.prices, self.signal_features = self._process_data()\n",
        "\n",
        "        # spaces\n",
        "        self.action_space = spaces.Discrete(3)\n",
        "        self.observation_space = spaces.Box(low=0, high=1999, shape=(1,) , dtype=np.float64)\n",
        "\n",
        "        # episode\n",
        "        self._start_tick = 0\n",
        "        self._end_tick = 0\n",
        "        self._done = None\n",
        "        self._current_tick = None\n",
        "        self._last_trade_tick = None\n",
        "        self._position = None\n",
        "        self._position_history = None\n",
        "        self._total_reward = None\n",
        "        self._total_profit = None\n",
        "        self._first_rendering = None\n",
        "        self.history = None\n",
        "        self._max_steps = max_steps\n",
        "        self._start_episode_tick = None\n",
        "        self._trade_history = None\n",
        "\n",
        "    def reset(self):\n",
        "        self._done = False\n",
        "        self._start_episode_tick = np.random.randint(1,len(self.df)- self._max_steps )\n",
        "        self._end_tick = self._start_episode_tick + self._max_steps\n",
        "        self._current_tick = self._start_episode_tick\n",
        "        self._last_trade_tick = self._current_tick - 1\n",
        "        self._position = 0\n",
        "        self._position_history = []\n",
        "        # self._position_history = (self.window_size * [None]) + [self._position]\n",
        "        self._total_reward = 0.\n",
        "        self._total_profit = 0.\n",
        "        self._trade_history = []\n",
        "        self.history = {}\n",
        "        return self._get_observation()\n",
        "\n",
        "\n",
        "    def step(self, action):\n",
        "        self._done = False\n",
        "        self._current_tick += 1\n",
        "\n",
        "        if self._current_tick == self._end_tick:\n",
        "            self._done = True\n",
        "\n",
        "        step_reward = self._calculate_reward(action)\n",
        "        self._total_reward += step_reward\n",
        "\n",
        "        observation = self._get_observation()\n",
        "        info = dict(\n",
        "            total_reward = self._total_reward,\n",
        "            total_profit = self._total_profit,\n",
        "            position = self._position,\n",
        "            action = action\n",
        "        )\n",
        "        self._update_history(info)\n",
        "\n",
        "        return observation, step_reward, self._done, info\n",
        "\n",
        "    def seed(self, seed=None):\n",
        "        self.np_random, seed = seeding.np_random(seed)\n",
        "        return [seed]\n",
        "        \n",
        "    def _get_observation(self):\n",
        "        return self.signal_features[self._current_tick]\n",
        "\n",
        "    def _update_history(self, info):\n",
        "        if not self.history:\n",
        "            self.history = {key: [] for key in info.keys()}\n",
        "\n",
        "        for key, value in info.items():\n",
        "            self.history[key].append(value)\n",
        "\n",
        "\n",
        "    def render(self, mode='human'):\n",
        "        window_ticks = np.arange(len(self._position_history))\n",
        "        prices = self.prices[self._start_episode_tick:self._end_tick+1]\n",
        "        plt.plot(prices)\n",
        "\n",
        "        open_buy = []\n",
        "        close_buy = []\n",
        "        open_sell = []\n",
        "        close_sell = []\n",
        "        do_nothing = []\n",
        "\n",
        "        for i, tick in enumerate(window_ticks):\n",
        "            if self._position_history[i] == 1:\n",
        "                open_buy.append(tick)\n",
        "            elif self._position_history[i] == 2 :\n",
        "                close_buy.append(tick)\n",
        "            elif self._position_history[i] == 3 :\n",
        "                open_sell.append(tick)\n",
        "            elif self._position_history[i] == 4 :\n",
        "                close_sell.append(tick)\n",
        "            elif self._position_history[i] == 0 :\n",
        "                do_nothing.append(tick)\n",
        "\n",
        "        plt.plot(open_buy, prices[open_buy], 'go', marker=\"^\")\n",
        "        plt.plot(close_buy, prices[close_buy], 'go', marker=\"v\")\n",
        "        plt.plot(open_sell, prices[open_sell], 'ro', marker=\"v\")\n",
        "        plt.plot(close_sell, prices[close_sell], 'ro', marker=\"^\")\n",
        "    \n",
        "        plt.plot(do_nothing, prices[do_nothing], 'yo')\n",
        "\n",
        "        plt.suptitle(\n",
        "            \"Total Reward: %.6f\" % self._total_reward + ' ~ ' +\n",
        "            \"Total Profit: %.6f\" % self._total_profit\n",
        "        )\n",
        "\n",
        "    def _calculate_reward(self, action):\n",
        "        step_reward = 0\n",
        "\n",
        "        current_price = self.prices[self._current_tick]\n",
        "        last_price = self.prices[self._current_tick - 1]\n",
        "        price_diff = current_price - last_price\n",
        "\n",
        "        penalty = -1 * last_price * 0.01\n",
        "        # OPEN BUY - 1\n",
        "        if action == Actions.Buy.value and self._position == 0:\n",
        "            self._position = 1\n",
        "            step_reward += price_diff\n",
        "            self._last_trade_tick = self._current_tick - 1\n",
        "            self._position_history.append(1)\n",
        "\n",
        "        elif action == Actions.Buy.value and self._position > 0:\n",
        "            step_reward += penalty\n",
        "            self._position_history.append(-1)\n",
        "        # CLOSE SELL - 4\n",
        "        elif action == Actions.Buy.value and self._position < 0:\n",
        "            self._position = 0\n",
        "            step_reward += -1 * (self.prices[self._current_tick -1] - self.prices[self._last_trade_tick]) \n",
        "            self._total_profit += step_reward\n",
        "            self._position_history.append(4)\n",
        "            self._trade_history.append(step_reward)\n",
        "\n",
        "        # OPEN SELL - 3\n",
        "        elif action == Actions.Sell.value and self._position == 0:\n",
        "            self._position = -1\n",
        "            step_reward += -1 * price_diff\n",
        "            self._last_trade_tick = self._current_tick - 1\n",
        "            self._position_history.append(3)\n",
        "        # CLOSE BUY - 2\n",
        "        elif action == Actions.Sell.value and self._position > 0:\n",
        "            self._position = 0\n",
        "            step_reward += self.prices[self._current_tick -1] - self.prices[self._last_trade_tick] \n",
        "            self._total_profit += step_reward\n",
        "            self._position_history.append(2)\n",
        "            self._trade_history.append(step_reward)\n",
        "        elif action == Actions.Sell.value and self._position < 0:\n",
        "            step_reward += penalty\n",
        "            self._position_history.append(-1)\n",
        "\n",
        "        # DO NOTHING - 0\n",
        "        elif action == Actions.Do_nothing.value and self._position > 0:\n",
        "            step_reward += price_diff\n",
        "            self._position_history.append(0)\n",
        "        elif action == Actions.Do_nothing.value and self._position < 0:\n",
        "            step_reward += -1 * price_diff\n",
        "            self._position_history.append(0)\n",
        "        elif action == Actions.Do_nothing.value and self._position == 0:\n",
        "            step_reward += -1 * abs(price_diff)\n",
        "            self._position_history.append(0)\n",
        "\n",
        "        return step_reward\n",
        "\n",
        "    def _do_bin(self,df):\n",
        "        df = pd.cut(df,bins=[0,10,20,30,40,50,60,70,80,90,100],labels=False, include_lowest=True)\n",
        "        return df\n",
        "    # Our state will be encode with 4 features MFI and Stochastic(only D line), ADX and DI+DI-\n",
        "    # the values of each feature will be binned in 10 bins, ex:\n",
        "    # MFI goes from 0-100, if we get 25 will put on the second bin \n",
        "    # DI+DI-  if DI+ is over DI- set (1 otherwise 0) \n",
        "    # \n",
        "    # that will give a state space of 10(MFI) * 10(STOCH) * 10(ADX) * 2(DI) = 2000 states\n",
        "    # encoded as bins of  DI MFI STOCH ADX = 1 45.2  25.4  90.1 , binned = 1 4 2 9 state = 1429   \n",
        "    def _process_data(self):\n",
        "        timeperiod = 14\n",
        "        self.df = self.df.copy()\n",
        "        \n",
        "        self.df['mfi_r'] = ta.MFI(self.df['High'], self.df['Low'], self.df['Close'],self.df['Volume'], timeperiod=timeperiod)\n",
        "        _, self.df['stock_d_r'] = ta.STOCH(self.df['High'], self.df['Low'], self.df['Close'], fastk_period=5, slowk_period=3, slowk_matype=0, slowd_period=3, slowd_matype=0)\n",
        "        self.df['adx_r'] = ta.ADX(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['p_di'] = ta.PLUS_DI(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['m_di'] = ta.MINUS_DI(self.df['High'], self.df['Low'], self.df['Close'], timeperiod=timeperiod)\n",
        "        self.df['di'] = np.where( self.df['p_di'] > self.df['m_di'], 1, 0)\n",
        "\n",
        "        self.df = self.df.dropna()\n",
        "        self.df['mfi'] = self._do_bin(self.df['mfi_r'])\n",
        "        self.df['stock_d'] = self._do_bin(self.df['stock_d_r'])\n",
        "        self.df['adx'] = self._do_bin(self.df['adx_r'])\n",
        "        self.df['state'] = self.df['di']*1000+ self.df['mfi']*100 + self.df['stock_d']*10 + self.df['adx']\n",
        "        self.df = self.df.dropna()\n",
        "        self.df['state'] =  self.df['state'].astype(\"int\")\n",
        "        prices = self.df.loc[:, 'Close'].to_numpy()\n",
        "        # print(self.df.head(30))\n",
        "\n",
        "        signal_features = self.df.loc[:, 'state'].to_numpy()\n",
        "\n",
        "        return prices, signal_features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 117,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Training parameters\n",
        "n_training_episodes = 10000  # Total training episodes\n",
        "learning_rate = 0.2          # Learning rate\n",
        "\n",
        "# Environment parameters\n",
        "max_steps = 20   # Max steps per episode\n",
        "gamma = 0.95                 # Discounting rate\n",
        "\n",
        "# Exploration parameters\n",
        "max_epsilon = 1.0             # Exploration probability at start\n",
        "# max_epsilon = 1.0             # Exploration probability at start\n",
        "min_epsilon = 0.05            # Minimum exploration probability \n",
        "# min_epsilon = 0.05            # Minimum exploration probability \n",
        "decay_rate = 0.0005            # Exponential decay rate for exploration prob"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 118,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "REhmfLkYNTiN",
        "outputId": "cf676f6d-83df-43f5-89fe-3258e0041d9d"
      },
      "outputs": [],
      "source": [
        "# create env\n",
        "env = CustTradingEnv(df=eth_train, max_steps=max_steps)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 119,
      "metadata": {},
      "outputs": [],
      "source": [
        "# create q-table\n",
        "\n",
        "action_space = env.action_space.n # buy sell do_nothing\n",
        "state_space = 2000\n",
        "\n",
        "Qtable_trading = initialize_q_table(state_space, action_space)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 120,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "1801"
            ]
          },
          "execution_count": 120,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "Qtable_trading, state_history = train(n_training_episodes, min_epsilon, max_epsilon, \n",
        "                        decay_rate, env, max_steps, Qtable_trading, learning_rate, gamma )\n",
        "len(np.where( Qtable_trading > 0 )[0])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 121,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 417
        },
        "id": "FIQ0OqtsO3jo",
        "outputId": "f98374ad-c7de-4dc4-80b1-25f018ad96eb"
      },
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1080x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,6))\n",
        "plt.cla()\n",
        "env.render()\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 105,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[1.329999999999984,\n",
              " 12.79000000000002,\n",
              " -2.5500000000000114,\n",
              " -3.6399999999999864,\n",
              " -1.8199999999999932]"
            ]
          },
          "execution_count": 105,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "env._trade_history"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 122,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "884"
            ]
          },
          "execution_count": 122,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "len(np.unique(state_history, return_counts=True)[1])\n",
        "# count = 0\n",
        "# for i in range(len(state_history)):\n",
        "#     if state_history[i] == 1987:\n",
        "#         count +=1\n",
        "# count"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 123,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "884"
            ]
          },
          "execution_count": 123,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Qtable_trading[1987]\n",
        "len(np.unique(env.signal_features))"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 108,
      "metadata": {},
      "outputs": [],
      "source": [
        "def evaluate_agent(env, max_steps, n_eval_episodes, Q):\n",
        "  \"\"\"\n",
        "  Evaluate the agent for ``n_eval_episodes`` episodes and returns average reward and std of reward.\n",
        "  :param env: The evaluation environment\n",
        "  :param n_eval_episodes: Number of episode to evaluate the agent\n",
        "  :param Q: The Q-table\n",
        "  :param seed: The evaluation seed array (for taxi-v3)\n",
        "  \"\"\"\n",
        "  episode_rewards = []\n",
        "  episode_profits = []\n",
        "  for episode in tqdm(range(n_eval_episodes)):\n",
        "    state = env.reset()\n",
        "    step = 0\n",
        "    done = False\n",
        "    total_rewards_ep = 0\n",
        "    total_profit_ep = 0\n",
        "    \n",
        "    for step in range(max_steps):\n",
        "      # Take the action (index) that have the maximum expected future reward given that state\n",
        "      action = greedy_policy(Q, state)\n",
        "      new_state, reward, done, info = env.step(action)\n",
        "      total_rewards_ep += reward\n",
        "        \n",
        "      if done:\n",
        "        break\n",
        "      state = new_state\n",
        "\n",
        "    episode_rewards.append(total_rewards_ep)\n",
        "    episode_profits.append(env.history['total_profit'][-1])\n",
        "    # print(env.history)\n",
        "    # env.render()\n",
        "    # assert 0\n",
        "\n",
        "  mean_reward = np.mean(episode_rewards)\n",
        "  std_reward = np.std(episode_rewards)\n",
        "  mean_profit = np.mean(episode_profits)\n",
        "  std_profit = np.std(episode_profits)\n",
        "\n",
        "  return mean_reward, std_reward, mean_profit, std_profit"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 143,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "application/vnd.jupyter.widget-view+json": {
              "model_id": "135863eba0b4449d91486c62b9e76b04",
              "version_major": 2,
              "version_minor": 0
            },
            "text/plain": [
              "  0%|          | 0/200 [00:00<?, ?it/s]"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        },
        {
          "data": {
            "text/plain": [
              "(-34.85927099999999, 44.20471291366289, 8.429850000000014, 27.436458836327613)"
            ]
          },
          "execution_count": 143,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "max_steps = 20 \n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps)\n",
        "n_eval_episodes = 200\n",
        "\n",
        "evaluate_agent(env_test, max_steps, n_eval_episodes, Qtable_trading)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 127,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1080x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          },
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,6))\n",
        "plt.cla()\n",
        "env_test.render()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 128,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "200 0.9852216748768473\n"
          ]
        }
      ],
      "source": [
        "def count_equal(env1, env2):\n",
        "    count=0\n",
        "    for i in np.unique(env1.signal_features):\n",
        "        if i in env2.signal_features:\n",
        "            count+=1\n",
        "    \n",
        "    print(count, count / len(np.unique(env2.signal_features)))\n",
        "\n",
        "count_equal(env, env_test)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.8.13 ('rl2')",
      "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.13"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "cd60ab8388a66026f336166410d6a8a46ddf65ece2e85ad2d46c8b98d87580d1"
      }
    },
    "widgets": {
      "application/vnd.jupyter.widget-state+json": {
        "01a2dbcb714e40148b41c761fcf43147": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "20b0f38ec3234ff28a62a286cd57b933": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "PasswordModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "PasswordModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "PasswordView",
            "continuous_update": true,
            "description": "Token:",
            "description_tooltip": null,
            "disabled": false,
            "layout": "IPY_MODEL_01a2dbcb714e40148b41c761fcf43147",
            "placeholder": "​",
            "style": "IPY_MODEL_90c874e91b304ee1a7ef147767ac00ce",
            "value": ""
          }
        },
        "270cbb5d6e9c4b1e9e2f39c8b3b0c15f": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "VBoxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "VBoxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "VBoxView",
            "box_style": "",
            "children": [
              "IPY_MODEL_a02224a43d8d4af3bd31d326540d25da",
              "IPY_MODEL_20b0f38ec3234ff28a62a286cd57b933",
              "IPY_MODEL_f6c845330d6743c0b35c2c7ad834de77",
              "IPY_MODEL_f1675c09d16a4251b403f9c56255f168",
              "IPY_MODEL_c1a82965ae26479a98e4fdbde1e64ec2"
            ],
            "layout": "IPY_MODEL_3fa248114ac24656ba74923936a94d2d"
          }
        },
        "2dc5fa9aa3334dfcbdee9c238f2ef60b": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "3e753b0212644990b558c68853ff2041": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "3fa248114ac24656ba74923936a94d2d": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": "center",
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": "flex",
            "flex": null,
            "flex_flow": "column",
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": "50%"
          }
        },
        "42d140b838b844819bc127afc1b7bc84": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "90c874e91b304ee1a7ef147767ac00ce": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "9d847f9a7d47458d8cd57d9b599e47c6": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "a02224a43d8d4af3bd31d326540d25da": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_caef095934ec47bbb8b64eab22049284",
            "placeholder": "​",
            "style": "IPY_MODEL_2dc5fa9aa3334dfcbdee9c238f2ef60b",
            "value": "<center> <img\nsrc=https://huggingface.co/front/assets/huggingface_logo-noborder.svg\nalt='Hugging Face'> <br> Copy a token from <a\nhref=\"https://huggingface.co/settings/tokens\" target=\"_blank\">your Hugging Face\ntokens page</a> and paste it below. <br> Immediately click login after copying\nyour token or it might be stored in plain text in this notebook file. </center>"
          }
        },
        "a2cfb91cf66447d7899292854bd64a07": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "c1a82965ae26479a98e4fdbde1e64ec2": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "HTMLModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "HTMLModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "HTMLView",
            "description": "",
            "description_tooltip": null,
            "layout": "IPY_MODEL_9d847f9a7d47458d8cd57d9b599e47c6",
            "placeholder": "​",
            "style": "IPY_MODEL_42d140b838b844819bc127afc1b7bc84",
            "value": "\n<b>Pro Tip:</b> If you don't already have one, you can create a dedicated\n'notebooks' token with 'write' access, that you can then easily reuse for all\nnotebooks. </center>"
          }
        },
        "caef095934ec47bbb8b64eab22049284": {
          "model_module": "@jupyter-widgets/base",
          "model_module_version": "1.2.0",
          "model_name": "LayoutModel",
          "state": {
            "_model_module": "@jupyter-widgets/base",
            "_model_module_version": "1.2.0",
            "_model_name": "LayoutModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "LayoutView",
            "align_content": null,
            "align_items": null,
            "align_self": null,
            "border": null,
            "bottom": null,
            "display": null,
            "flex": null,
            "flex_flow": null,
            "grid_area": null,
            "grid_auto_columns": null,
            "grid_auto_flow": null,
            "grid_auto_rows": null,
            "grid_column": null,
            "grid_gap": null,
            "grid_row": null,
            "grid_template_areas": null,
            "grid_template_columns": null,
            "grid_template_rows": null,
            "height": null,
            "justify_content": null,
            "justify_items": null,
            "left": null,
            "margin": null,
            "max_height": null,
            "max_width": null,
            "min_height": null,
            "min_width": null,
            "object_fit": null,
            "object_position": null,
            "order": null,
            "overflow": null,
            "overflow_x": null,
            "overflow_y": null,
            "padding": null,
            "right": null,
            "top": null,
            "visibility": null,
            "width": null
          }
        },
        "eaba3f1de4444aabadfea2a3dadb1d80": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "DescriptionStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "DescriptionStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "description_width": ""
          }
        },
        "ee4a21bedc504171ad09d205d634b528": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonStyleModel",
          "state": {
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonStyleModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/base",
            "_view_module_version": "1.2.0",
            "_view_name": "StyleView",
            "button_color": null,
            "font_weight": ""
          }
        },
        "f1675c09d16a4251b403f9c56255f168": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "ButtonModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "ButtonModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "ButtonView",
            "button_style": "",
            "description": "Login",
            "disabled": false,
            "icon": "",
            "layout": "IPY_MODEL_a2cfb91cf66447d7899292854bd64a07",
            "style": "IPY_MODEL_ee4a21bedc504171ad09d205d634b528",
            "tooltip": ""
          }
        },
        "f6c845330d6743c0b35c2c7ad834de77": {
          "model_module": "@jupyter-widgets/controls",
          "model_module_version": "1.5.0",
          "model_name": "CheckboxModel",
          "state": {
            "_dom_classes": [],
            "_model_module": "@jupyter-widgets/controls",
            "_model_module_version": "1.5.0",
            "_model_name": "CheckboxModel",
            "_view_count": null,
            "_view_module": "@jupyter-widgets/controls",
            "_view_module_version": "1.5.0",
            "_view_name": "CheckboxView",
            "description": "Add token as git credential?",
            "description_tooltip": null,
            "disabled": false,
            "indent": true,
            "layout": "IPY_MODEL_3e753b0212644990b558c68853ff2041",
            "style": "IPY_MODEL_eaba3f1de4444aabadfea2a3dadb1d80",
            "value": true
          }
        }
      }
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}