{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nwaAZRu1NTiI"
      },
      "source": [
        "# PPO\n",
        "\n",
        "\n",
        "#### This version uses stable baseline PPO using a custom enviroment (unit 8)"
      ]
    },
    {
      "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 PPO\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": 10,
      "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 = PPO(\"MlpPolicy\", env, n_steps=8, verbose=1)\n",
        "# model.learn(total_timesteps=1000)\n",
        "model.learn(total_timesteps=1_000_000)\n",
        "model.save(\"./alt/ppo_tradeenv-100\")\n",
        "\n",
        "env.close()\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "['./alt/fin_rl_ppo_100_v1.h5_scaler']"
            ]
          },
          "execution_count": 5,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "joblib.dump(env.get_scaler(),\"./alt/fin_rl_ppo_100_v1.h5_scaler\")"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "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 PPO 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",
        "    if len(env._trade_history) > 0:\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",
        "  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": 7,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-198.7888042614746, 262.73996495315777, -39.8325263671875, 168.48438530582132)"
            ]
          },
          "execution_count": 7,
          "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": 8,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-1890.4923852539064, 0.0, -412.2003173828125, 0.0)"
            ]
          },
          "execution_count": 8,
          "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": 6,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/Users/viewitpro/projetos/anaconda3/envs/aivai/lib/python3.9/site-packages/sklearn/base.py:299: UserWarning: Trying to unpickle estimator MinMaxScaler from version 1.0.2 when using version 1.2.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n",
            "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n",
            "  warnings.warn(\n"
          ]
        }
      ],
      "source": [
        "# load model and scaler from file\n",
        "max_steps = 20 \n",
        "scaler_l = joblib.load(\"./alt/fin_rl_ppo_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 = PPO.load(\"./alt/ppo_tradeenv-100\")\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-1170.7661828613282, 0.0, 464.621826171875, 0.0, 0.8421052631578947)"
            ]
          },
          "execution_count": 11,
          "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": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "/var/folders/r6/jgl8b48s325fbkg5jwkg93fc0000gn/T/ipykernel_4255/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_4255/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_4255/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_4255/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": 13,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-102.37856498901368,\n",
              " 182.69667153506305,\n",
              " 78.38524426269531,\n",
              " 95.87832378626631,\n",
              " 0.7969576719576719)"
            ]
          },
          "execution_count": 13,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# This does 1000 episodes with random_starts of date trading for max 20 steps \n",
        "max_steps = 20 \n",
        "env_test_rand = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env_l.get_scaler())\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_test_rand, max_steps, n_eval_episodes, model_l)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "text/plain": [
              "(-134.11111313598636,\n",
              " 331.10017018010296,\n",
              " 5.856146362304687,\n",
              " 180.9655759976027,\n",
              " 0.48736071428571426)"
            ]
          },
          "execution_count": 17,
          "metadata": {},
          "output_type": "execute_result"
        }
      ],
      "source": [
        "# 1000 trades 20 steps random actions\n",
        "max_steps = 20 \n",
        "env_test_rand = CustTradingEnv(df=eth_test, max_steps=max_steps, random_start=True, scaler=env_l.get_scaler())\n",
        "n_eval_episodes = 1000\n",
        "\n",
        "evaluate_agent(env_test_rand, max_steps, n_eval_episodes, model_l, random=True)"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Mean profit -3.29887353515625\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_l.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_l, 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",
        "|PPO         | 78.38                | 464.62             | 5.85                               | -3.29            |\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": 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
}