{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nwaAZRu1NTiI"
      },
      "source": [
        "# A2C\n",
        "\n",
        "\n",
        "#### This version uses stable baseline A2C using a custom enviroment (unit 6)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "!pip install yfinance\n",
        "\n",
        "# install talib in colab\n",
        "!wget http://prdownloads.sourceforge.net/ta-lib/ta-lib-0.4.0-src.tar.gz\n",
        "!tar -xzvf ta-lib-0.4.0-src.tar.gz\n",
        "%cd ta-lib\n",
        "!./configure --prefix=/usr\n",
        "!make\n",
        "!make install\n",
        "!pip install Ta-Lib\n",
        "import talib as ta"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "LNXxxKojNTiL"
      },
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "import gym\n",
        "from gym import spaces\n",
        "from gym.utils import seeding\n",
        "from gym import wrappers\n",
        "\n",
        "from stable_baselines3 import A2C\n",
        "from stable_baselines3.common.env_checker import check_env\n",
        "\n",
        "from tqdm.notebook import tqdm\n",
        "from collections import deque\n",
        "import numpy as np\n",
        "import random\n",
        "from matplotlib import pyplot as plt\n",
        "from sklearn.preprocessing import MinMaxScaler\n",
        "import joblib\n",
        "\n",
        "import talib as ta\n",
        "import yfinance as yf\n",
        "import pandas as pd\n",
        "\n",
        "import io\n",
        "import base64\n",
        "from IPython.display import HTML, Video\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "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",
        "\n",
        "    def __init__(self, df, max_steps=0, seed=8, random_start=True, scaler=None):\n",
        "        self.seed(seed=seed)\n",
        "        self.df = df\n",
        "        if scaler is None:\n",
        "            self.scaler = MinMaxScaler()\n",
        "        else:\n",
        "            self.scaler = scaler\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=1, shape=(4,) , 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",
        "        self._random_start = random_start\n",
        "\n",
        "\n",
        "    def reset(self):\n",
        "        self._done = False\n",
        "        if self._random_start:\n",
        "            self._start_episode_tick = np.random.randint(1,high=len(self.df)- self._max_steps )\n",
        "            self._end_tick = self._start_episode_tick + self._max_steps\n",
        "        else:\n",
        "            self._start_episode_tick = 1\n",
        "            self._end_tick = len(self.df)-1\n",
        "\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 get_scaler(self):\n",
        "        return self.scaler\n",
        "\n",
        "    def set_scaler(self, scaler):\n",
        "        self.scaler = scaler\n",
        " \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['stoch_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['di_s']=self.df['di']\n",
        "        # self.df['mfi_s']=self.df['mfi_r']\n",
        "        # self.df['stoch_d_s']=self.df['stoch_d_r']\n",
        "        # self.df['adx_s']=self.df['adx_r']\n",
        "\n",
        "        self.df[['di_s','mfi_s','stoch_d_s','adx_s']] = self.scaler.fit_transform(self.df[['di','mfi_r','stoch_d_r','adx_r']])\n",
        "\n",
        "        def f1(row):\n",
        "            row['state'] = [row['di_s'], row['mfi_s'], row['stoch_d_s'], row['adx_s']]\n",
        "            return row\n",
        "\n",
        "        self.df = self.df.apply(f1, axis=1 )\n",
        "\n",
        "        prices = self.df.loc[:, 'Close'].to_numpy()\n",
        "        # print(self.df.head(30))\n",
        "\n",
        "        signal_features = np.stack(self.df.loc[:, 'state'].to_numpy())\n",
        "\n",
        "        return prices, signal_features"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "3075\n",
            "1926\n"
          ]
        }
      ],
      "source": [
        "# Get data\n",
        "eth_usd = yf.Ticker(\"ETH-USD\")\n",
        "eth = eth_usd.history(period=\"max\")\n",
        "\n",
        "btc_usd = yf.Ticker(\"BTC-USD\")\n",
        "btc = btc_usd.history(period=\"max\")\n",
        "print(len(btc))\n",
        "print(len(eth))\n",
        "\n",
        "btc_train = eth[-3015:-200]\n",
        "# btc_test = eth[-200:]\n",
        "eth_train = eth[-1864:-200]\n",
        "eth_test = eth[-200:]\n",
        "# len(eth_train)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": [
        "# create env\n",
        "max_steps = 20  \n",
        "env = CustTradingEnv(df=eth_train, max_steps=max_steps)\n",
        "\n",
        "# check_env(env)\n",
        "\n",
        "model = A2C(\"MlpPolicy\", env, verbose=1)\n",
        "# model.learn(total_timesteps=1000)\n",
        "model.learn(total_timesteps=1_000_000)\n",
        "model.save(\"./alt/a2c_tradeenv-100\")\n",
        "\n",
        "env.close()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['./alt/fin_rl_a2c_100_v1.h5_scaler']"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "joblib.dump(env.get_scaler(),\"./alt/fin_rl_a2c_100_v1.h5_scaler\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {},
      "outputs": [],
      "source": [
        "\n",
        "\n",
        "def evaluate_agent(env, max_steps, n_eval_episodes, model, random=False):\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 model: The A2C model\n",
        "  \"\"\"\n",
        "  episode_positive_perc_trades = []\n",
        "  episode_rewards = []\n",
        "  episode_profits = []\n",
        "  for episode in range(n_eval_episodes):\n",
        "#   for episode in tqdm(range(n_eval_episodes), disable=random):\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",
        "      if random:\n",
        "        action = env.action_space.sample()\n",
        "      else:\n",
        "        action, _states = model.predict(state)\n",
        "        # action = model.play(state)\n",
        "    # print(action)\n",
        "        \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_positive_perc_trades.append(np.count_nonzero(np.array(env._trade_history) > 0)/len(env._trade_history))\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",
        "\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",
        "  positive_perc_trades = np.mean(episode_positive_perc_trades)\n",
        "\n",
        "  return mean_reward, std_reward, mean_profit, std_profit, positive_perc_trades"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 49,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-59.88053379638672, 247.5485386506795, 61.646527954101565, 134.4789860013969)"
            ]
          },
          "execution_count": 49,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade with random start in the test set \n",
        "max_steps = 20 \n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_test, max_steps, n_eval_episodes, model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(52.61416015624997, 0.0, 734.18408203125, 0.0)"
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade sequentially in the test set\n",
        "max_steps = len(eth_test)\n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=False, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1\n",
        "\n",
        "evaluate_agent(env_test, max_steps, n_eval_episodes, model)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {},
      "outputs": [],
      "source": [
        "# load model and scaler from file\n",
        "max_steps = 20 \n",
        "scaler_l = joblib.load(\"./alt/fin_rl_a2c_100_v1.h5_scaler\")\n",
        "env_l = CustTradingEnv(df=eth_test, max_steps=max_steps, scaler=scaler_l, random_start=False)\n",
        "\n",
        "model_l = A2C.load(\"./alt/a2c_tradeenv-100\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 47,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-206.34888549804703, 0.0, 835.0531005859375, 0.0, 0.5757575757575758)"
            ]
          },
          "execution_count": 47,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade sequentially the loaded model and env\n",
        "max_steps = len(eth_test)\n",
        "n_eval_episodes = 1\n",
        "evaluate_agent(env_l, max_steps, n_eval_episodes, model_l)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_1535/1075875040.py:120: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_buy, prices[open_buy], 'go', marker=\"^\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_1535/1075875040.py:121: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"go\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_buy, prices[close_buy], 'go', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_1535/1075875040.py:122: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(open_sell, prices[open_sell], 'ro', marker=\"v\")\n",
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_1535/1075875040.py:123: UserWarning: marker is redundantly defined by the 'marker' keyword argument and the fmt string \"ro\" (-> marker='o'). The keyword argument will take precedence.\n",
            "  plt.plot(close_sell, prices[close_sell], 'ro', marker=\"^\")\n"
          ]
        },
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 1500x600 with 1 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "plt.figure(figsize=(15,6))\n",
        "plt.cla()\n",
        "env_l.render()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 50,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-120.95832889160155,\n",
              " 308.2148780853829,\n",
              " 87.36779748535156,\n",
              " 175.72397852270547,\n",
              " 0.6238309523809523)"
            ]
          },
          "execution_count": 50,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# trade with random start in the test set \n",
        "max_steps = 20 \n",
        "scaler_l = joblib.load(\"./alt/fin_rl_a2c_100_v1.h5_scaler\")\n",
        "env_l = CustTradingEnv(df=eth_test, max_steps=max_steps, scaler=scaler_l, random_start=False)\n",
        "model_l = A2C.load(\"./alt/a2c_tradeenv-100\")\n",
        "\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_l, max_steps, n_eval_episodes, model_l)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 42,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-143.71849208740235,\n",
              " 327.02519292656416,\n",
              " -2.4958328857421876,\n",
              " 173.71400360701966)"
            ]
          },
          "execution_count": 42,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# Test for random n_eval_episodes\n",
        "max_steps = 20 \n",
        "env_test_rand = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_test_rand, max_steps, n_eval_episodes, model, random=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 43,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mean profit 22.493475219726562\n"
          ]
        }
      ],
      "source": [
        "# trade sequentially with random actions \n",
        "max_steps = len(eth_test)\n",
        "env_test = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=False, scaler=env.get_scaler())\n",
        "n_eval_episodes = 1\n",
        "\n",
        "all_profit=[]\n",
        "for i in range(1000):\n",
        "    _,_,profit,_=evaluate_agent(env_test, max_steps, n_eval_episodes, model, random=True)\n",
        "    all_profit.append(profit)\n",
        "print(f\"Mean profit {np.mean(all_profit)}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "## Results\n",
        "\n",
        "| Model      | 1000 trades 20 steps | Sequential trading | 1000 trades 20 steps random actions | Sequential random|\n",
        "|------------|----------------------|--------------------|-------------------------------------|------------------|\n",
        "|Q-learning  | 113.14               | 563.67             | -18.10                              | 39.30            |\n",
        "|DQN         | 87.62                | 381.17             | 4.95                                | 3.77             |\n",
        "|A2c         | 61.64                | 734.18             | -2.49                               | 22.49            |\n",
        "\n",
        "#### Actions are: Buy/Sell/Hold 1 ETH \n",
        "##### Model trading\n",
        "1000 trades 20 steps - Made 1000 episodes, 20 trades each episode, result is the mean return of each episode \n",
        "\n",
        "Sequential trading (175 days)- Trade the test set sequentially from start to end day \n",
        "##### Random trading (to compare against model trading)\n",
        "1000 trades 20 steps random actions - Made 1000 episodes, 20 trades each episode taking random actions \n",
        "\n",
        "Sequential random (175 days)- Trade the test set sequentially from start to end day with random actions "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": []
    },
    {
      "cell_type": "code",
      "execution_count": 57,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "[126.3253173828125,\n",
              " -39.5416259765625,\n",
              " -73.59912109375,\n",
              " -5.3201904296875,\n",
              " 109.094482421875,\n",
              " 4.8367919921875,\n",
              " 146.1649169921875,\n",
              " -11.0887451171875,\n",
              " 28.9151611328125,\n",
              " 53.002685546875,\n",
              " -96.42626953125,\n",
              " 472.06494140625,\n",
              " -104.337646484375,\n",
              " -19.4146728515625,\n",
              " 34.6265869140625,\n",
              " -5.2696533203125,\n",
              " -10.75048828125,\n",
              " 152.289794921875,\n",
              " 32.0098876953125,\n",
              " -5.8258056640625,\n",
              " 22.8055419921875,\n",
              " 88.126708984375,\n",
              " 66.393798828125,\n",
              " -33.6763916015625,\n",
              " 1.7725830078125,\n",
              " -8.9874267578125,\n",
              " -37.049560546875,\n",
              " 32.635986328125,\n",
              " -71.77783203125,\n",
              " -8.6051025390625,\n",
              " 43.63623046875,\n",
              " 21.5040283203125,\n",
              " -35.413330078125,\n",
              " 76.3203125]"
            ]
          },
          "execution_count": 57,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "env_l._trade_history"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {},
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python 3.9.16 ('aivai')",
      "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.9.16"
    },
    "orig_nbformat": 4,
    "vscode": {
      "interpreter": {
        "hash": "e0a9bccbe122e523b955ec22d341fa640296741eab9d9470e0d68ebe33390ade"
      }
    },
    "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
}