DDQN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import annotations\n",
    "\n",
    "import itertools\n",
    "import logging\n",
    "import os\n",
    "os.environ['OPENBLAS_NUM_THREADS'] = '4'\n",
    "os.environ['MKL_NUM_THREADS'] = '4'\n",
    "os.environ['NUMEXPR_NUM_THREADS'] = '4'\n",
    "os.environ['OMP_NUM_THREADS'] = '4'\n",
    "os.environ[\"VECLIB_MAXIMUM_THREADS\"] = \"4\"\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.stats import norm\n",
    "\n",
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output\n",
    "\n",
    "from golds.contracts import Currency, Stock, Option, OptionFlavor, OptionStyle, Holdings, Valuation\n",
    "from golds.env import AmericanOptionEnv\n",
    "from golds.mkt_data import PricingSource, SingleStockGBMMarketDataSource\n",
    "from golds.params import GBMParams\n",
    "from golds.reward_functions import NaiveHedgingRewardFunction, RewardFunction\n",
    "from golds.tcost import NaiveTransactionCostModel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DDQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        obs_input: pd.DataFrame,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "        \n",
    "        self.obs_input = obs_input\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 1000):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "        rewards = []\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "                \n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                prev_pos = None\n",
    "                preds = []\n",
    "                \n",
    "                for _t in sorted(self.obs_input['normalized_time'].unique()):\n",
    "                    prev_pos = np.ones(self.obs_input['episode_idx'].max() + 1) * 100 if prev_pos is None else prev_pos\n",
    "                    obs = np.hstack([self.obs_input.loc[self.obs_input['normalized_time'] == _t, ['price', 'call_price','all_1', 'normalized_time',]].values, prev_pos[:, np.newaxis], np.zeros((self.obs_input['episode_idx'].max() + 1, 2))])\n",
    "                    pred = np.zeros(len(obs))\n",
    "                    for j in range(len(obs)):\n",
    "                        pred[j] = self.select_action(obs[j]) - 100\n",
    "                    prev_pos = pred\n",
    "                    preds.append(pred)\n",
    "                    \n",
    "                self.obs_input['holdings'] = np.concatenate(preds)\n",
    "                self.obs_input = self.obs_input.sort_values(['episode_idx', 'normalized_time'])\n",
    "                self.obs_input = self._calculate_reward_vectorize(self.obs_input)\n",
    "                \n",
    "                action_fn_df: pd.DataFrame = self.obs_input[['holdings', 'reward']]\n",
    "                    \n",
    "                reward_value = action_fn_df.reward.median()\n",
    "                    \n",
    "                rewards.append(reward_value)\n",
    "                \n",
    "                stock_price_list = [98, 100, 102]\n",
    "\n",
    "                for price in stock_price_list:   \n",
    "                    mu = 0.02 / 252\n",
    "                    sigma = 0.09 / np.sqrt(252)\n",
    "                    r = 0.0 / 252\n",
    "\n",
    "                    stock_holdings = np.arange(-100,-19)\n",
    "                    obs_length = len(stock_holdings)\n",
    "                    stock_price = np.repeat(price, obs_length)\n",
    "                    obs_3 = np.repeat(1, obs_length)\n",
    "                    time_to_maturity = np.repeat(49 / 252, obs_length)\n",
    "                    obs_6 = np.repeat(0, obs_length)\n",
    "                    obs_7 = np.repeat(0, obs_length)\n",
    "                    t = 49/50\n",
    "\n",
    "                    res = pd.DataFrame.from_dict({'stock_price': stock_price, 'obs_3': obs_3, 'stock_holdings': stock_holdings, \n",
    "                                             'time_to_maturity':time_to_maturity, 'obs_6': obs_6,'obs_7': obs_7, 't':t})\n",
    "                    res['delta'] = norm.cdf((np.log(res['stock_price'] / 100) + (r * 252 + 0.5 * 252 * sigma ** 2) * (1 - res['time_to_maturity'])) /\\\n",
    "                        np.sqrt(252) / sigma / np.sqrt((1 - res['time_to_maturity'])))\n",
    "                    res['call_price'] = res['stock_price'] * res['delta'] - 100 * np.exp(-r * 252 * (1 - res['time_to_maturity'])) * norm.cdf((np.log(res['stock_price'] / 100)\\\n",
    "                         + (r * 252 - 0.5 * 252 * sigma ** 2) * (1 - res['time_to_maturity'])) / np.sqrt(252) / sigma / np.sqrt((1 - res['time_to_maturity'])))\n",
    "\n",
    "                    obs = res[[\"stock_price\",\"call_price\",\"obs_3\",\"t\",\"stock_holdings\",\"obs_6\",\"obs_7\"]].to_numpy()\n",
    "                    \n",
    "                    actions = np.zeros(len(obs))\n",
    "                    for j in range(len(obs)):\n",
    "                        actions[j] = self.select_action(obs[j]) - 100\n",
    "\n",
    "                    if price < 100:\n",
    "                        oom_actions = list(actions)\n",
    "                    elif price == 100:\n",
    "                        atm_actions = list(actions)\n",
    "                    else:\n",
    "                        itm_actions = list(actions)\n",
    "                \n",
    "                self._plot(frame_idx, scores, rewards, losses, epsilons, oom_actions, atm_actions, itm_actions)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> List[np.ndarray]:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        frames = []\n",
    "        while not done:\n",
    "            frames.append(self.env.render(mode=\"rgb_array\"))\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "        \n",
    "        return frames\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        rewards: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "        oom_actions: List[float],\n",
    "        atm_actions: List[float],\n",
    "        itm_actions: List[float]\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(10, 25))\n",
    "        plt.subplot(411)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(412)\n",
    "        plt.title('frame %s. ' % (frame_idx))\n",
    "        plt.plot(rewards, marker='x')\n",
    "        plt.semilogx()\n",
    "        plt.subplot(413)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(414)\n",
    "        stock_holdings = np.arange(-100,-19)\n",
    "        delta_oom = - stock_holdings\n",
    "        delta_atm = -50 - stock_holdings\n",
    "        delta_itm = -100 - stock_holdings\n",
    "        plt.title('policy plot')\n",
    "        plt.plot(stock_holdings, delta_oom, ls=\"-\" , label=\"Delta Out of Money\", color=\"red\") \n",
    "        plt.plot(stock_holdings, delta_atm, ls=\"-\" , label=\"Delta At The Money\", color=\"blue\") \n",
    "        plt.plot(stock_holdings, delta_itm, ls=\"-\" , label=\"Delta In The Money\", color=\"green\") \n",
    "        plt.scatter(stock_holdings, oom_actions - stock_holdings, label=\"DQN Out of Money\", color=\"red\", s=8) \n",
    "        plt.scatter(stock_holdings, atm_actions - stock_holdings, label=\"DQN At The Money\", color=\"blue\", s=8) \n",
    "        plt.scatter(stock_holdings, itm_actions - stock_holdings, label=\"DQN In The Money\", color=\"green\", s=8) \n",
    "        plt.gca().invert_xaxis()\n",
    "        plt.legend(loc='upper center', bbox_to_anchor=(1.3, 0.5), fancybox=True)\n",
    "        plt.show()\n",
    "    \n",
    "    def _calculate_reward_vectorize(self, res: pd.DataFrame):\n",
    "        res['delta_wealth'] = res['holdings'].shift() * res['price'] + 100 * res['call_price'] - (res['holdings'] * res['price'] + 100 * res['call_price']).shift()\n",
    "        res.loc[res['normalized_time']==res['normalized_time'].min(), 'delta_wealth'] = 0.\n",
    "        res['reward'] = res['delta_wealth'] ** 2 * -0.5 * 0.1\n",
    "        return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_training_environment(save_dir: str):\n",
    "    aapl = Stock(ticker=\"AAPL\", is_tradable=True)\n",
    "    # TODO we can also make the option parameters part of the config\n",
    "    warrant = Option(\n",
    "        strike=100,\n",
    "        expiry_time=1.,\n",
    "        underlying=aapl,\n",
    "        flavor=OptionFlavor.CALL,\n",
    "        style=OptionStyle.EUROPEAN,\n",
    "        is_tradable=False\n",
    "    )\n",
    "    cash = Currency(code=\"USD\", is_tradable=False)\n",
    "\n",
    "    initial_holdings: Holdings = {\n",
    "        aapl: 0,\n",
    "        warrant: 100,\n",
    "        cash: 0,\n",
    "    }\n",
    "\n",
    "    universe = list(initial_holdings.keys())\n",
    "\n",
    "    gbm_params = GBMParams(mu=0.02, sigma=0.09, risk_free_rate=0.0)\n",
    "\n",
    "    mkt_data_source = SingleStockGBMMarketDataSource(universe, gbm_params, data_reuse_num_episodes=10000)\n",
    "    tcost_model = NaiveTransactionCostModel(universe)\n",
    "    pricing_source = PricingSource(mkt_data_source, tcost_model)\n",
    "\n",
    "    reward_clip_range = (-200, 200)\n",
    "    reward_records_save_path = os.path.join(save_dir, \"ddqn_reward_history.h5\")\n",
    "\n",
    "    valid_actions = {'lo': -100, 'hi': 100}\n",
    "\n",
    "    reward_function: RewardFunction = NaiveHedgingRewardFunction(\n",
    "        kappa=0.1,\n",
    "        initial_holdings=initial_holdings,\n",
    "        reward_clip_range=reward_clip_range,\n",
    "        reward_records_save_path=reward_records_save_path\n",
    "    )\n",
    "\n",
    "    return AmericanOptionEnv(\n",
    "        episode_length=50,\n",
    "        pricing_source=pricing_source,\n",
    "        reward_function=reward_function,\n",
    "        actions_config=valid_actions\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_evaluation_paths():\n",
    "    episode_length=50\n",
    "    nepisodes = 100\n",
    "    mu=0.02 / 252\n",
    "    sigma=0.09 / np.sqrt(252)\n",
    "    r=0.0 / 252\n",
    "    np.random.seed(42)\n",
    "    randns = np.random.randn(nepisodes * episode_length)\n",
    "    res = pd.DataFrame.from_dict({'episode_idx': np.repeat(np.arange(nepisodes), episode_length), 'randn': randns})\n",
    "    res['time_to_maturity'] = np.tile(1 + np.arange(episode_length), nepisodes) / 252\n",
    "    res['cum_randn'] = res.groupby('episode_idx')['randn'].cumsum()\n",
    "    res['price'] = res['cum_randn'] * sigma + (mu - sigma ** 2 / 2 * res['time_to_maturity'] * 252)\n",
    "    res['price'] = 100 * np.exp(res['price'])\n",
    "    res['all_1'] = 1.\n",
    "    res['normalized_time'] = np.tile(1 + np.arange(episode_length), nepisodes) / episode_length\n",
    "    res['delta'] = norm.cdf((np.log(res['price'] / 100) + (r * 252 + 0.5 * 252 * sigma ** 2) * (1 - res['time_to_maturity'])) /\\\n",
    "        np.sqrt(252) / sigma / np.sqrt((1 - res['time_to_maturity'])))\n",
    "    res['call_price'] = res['price'] * res['delta'] - 100 * np.exp(-r * 252 * (1 - res['time_to_maturity'])) * norm.cdf((np.log(res['price'] / 100)\\\n",
    "         + (r * 252 - 0.5 * 252 * sigma ** 2) * (1 - res['time_to_maturity'])) / np.sqrt(252) / sigma / np.sqrt((1 - res['time_to_maturity'])))\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>episode_idx</th>\n",
       "      <th>randn</th>\n",
       "      <th>time_to_maturity</th>\n",
       "      <th>cum_randn</th>\n",
       "      <th>price</th>\n",
       "      <th>all_1</th>\n",
       "      <th>normalized_time</th>\n",
       "      <th>delta</th>\n",
       "      <th>call_price</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>0.496714</td>\n",
       "      <td>0.003968</td>\n",
       "      <td>0.496714</td>\n",
       "      <td>100.288355</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.530675</td>\n",
       "      <td>3.733329</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>50</th>\n",
       "      <td>1</td>\n",
       "      <td>0.324084</td>\n",
       "      <td>0.003968</td>\n",
       "      <td>0.324084</td>\n",
       "      <td>100.190248</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.526339</td>\n",
       "      <td>3.681479</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>100</th>\n",
       "      <td>2</td>\n",
       "      <td>-1.415371</td>\n",
       "      <td>0.003968</td>\n",
       "      <td>-1.415371</td>\n",
       "      <td>99.207050</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.482563</td>\n",
       "      <td>3.185464</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>150</th>\n",
       "      <td>3</td>\n",
       "      <td>0.250493</td>\n",
       "      <td>0.003968</td>\n",
       "      <td>0.250493</td>\n",
       "      <td>100.148456</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.524490</td>\n",
       "      <td>3.659521</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>200</th>\n",
       "      <td>4</td>\n",
       "      <td>0.357787</td>\n",
       "      <td>0.003968</td>\n",
       "      <td>0.357787</td>\n",
       "      <td>100.209395</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.02</td>\n",
       "      <td>0.527186</td>\n",
       "      <td>3.691565</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4799</th>\n",
       "      <td>95</td>\n",
       "      <td>0.739180</td>\n",
       "      <td>0.198413</td>\n",
       "      <td>-11.553985</td>\n",
       "      <td>93.591638</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.217215</td>\n",
       "      <td>0.900958</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4849</th>\n",
       "      <td>96</td>\n",
       "      <td>0.479361</td>\n",
       "      <td>0.198413</td>\n",
       "      <td>-6.045505</td>\n",
       "      <td>96.560638</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.346769</td>\n",
       "      <td>1.731934</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4899</th>\n",
       "      <td>97</td>\n",
       "      <td>0.603791</td>\n",
       "      <td>0.198413</td>\n",
       "      <td>0.306237</td>\n",
       "      <td>100.101251</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.521074</td>\n",
       "      <td>3.266244</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4949</th>\n",
       "      <td>98</td>\n",
       "      <td>0.434503</td>\n",
       "      <td>0.198413</td>\n",
       "      <td>5.852585</td>\n",
       "      <td>103.298930</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.671149</td>\n",
       "      <td>5.177527</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4999</th>\n",
       "      <td>99</td>\n",
       "      <td>-0.848066</td>\n",
       "      <td>0.198413</td>\n",
       "      <td>4.537276</td>\n",
       "      <td>102.531484</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.00</td>\n",
       "      <td>0.637034</td>\n",
       "      <td>4.675451</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>5000 rows × 9 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "      episode_idx     randn  time_to_maturity  cum_randn       price  all_1  \\\n",
       "0               0  0.496714          0.003968   0.496714  100.288355    1.0   \n",
       "50              1  0.324084          0.003968   0.324084  100.190248    1.0   \n",
       "100             2 -1.415371          0.003968  -1.415371   99.207050    1.0   \n",
       "150             3  0.250493          0.003968   0.250493  100.148456    1.0   \n",
       "200             4  0.357787          0.003968   0.357787  100.209395    1.0   \n",
       "...           ...       ...               ...        ...         ...    ...   \n",
       "4799           95  0.739180          0.198413 -11.553985   93.591638    1.0   \n",
       "4849           96  0.479361          0.198413  -6.045505   96.560638    1.0   \n",
       "4899           97  0.603791          0.198413   0.306237  100.101251    1.0   \n",
       "4949           98  0.434503          0.198413   5.852585  103.298930    1.0   \n",
       "4999           99 -0.848066          0.198413   4.537276  102.531484    1.0   \n",
       "\n",
       "      normalized_time     delta  call_price  \n",
       "0                0.02  0.530675    3.733329  \n",
       "50               0.02  0.526339    3.681479  \n",
       "100              0.02  0.482563    3.185464  \n",
       "150              0.02  0.524490    3.659521  \n",
       "200              0.02  0.527186    3.691565  \n",
       "...               ...       ...         ...  \n",
       "4799             1.00  0.217215    0.900958  \n",
       "4849             1.00  0.346769    1.731934  \n",
       "4899             1.00  0.521074    3.266244  \n",
       "4949             1.00  0.671149    5.177527  \n",
       "4999             1.00  0.637034    4.675451  \n",
       "\n",
       "[5000 rows x 9 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "action_fn_observation_grid = get_evaluation_paths()\n",
    "obs_input = action_fn_observation_grid.sort_values(['normalized_time', 'episode_idx'])\n",
    "obs_input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_dir = os.getcwd()\n",
    "env = get_training_environment(save_dir)\n",
    "action_space = env.action_space"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cpu\n"
     ]
    }
   ],
   "source": [
    "num_frames = 12500000\n",
    "memory_size = 10000\n",
    "batch_size = 32\n",
    "target_update = 1000\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DDQNAgent(env, memory_size, batch_size, target_update, epsilon_decay, obs_input)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x1800 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "prev_pos = None\n",
    "preds = []\n",
    "\n",
    "for _t in sorted(obs_input['normalized_time'].unique()):\n",
    "    prev_pos = np.ones(obs_input['episode_idx'].max() + 1) * 100 if prev_pos is None else prev_pos\n",
    "    obs = np.hstack([obs_input.loc[obs_input['normalized_time'] == _t, ['price', 'call_price', 'all_1','normalized_time',]].values, prev_pos[:, np.newaxis], np.zeros((obs_input['episode_idx'].max() + 1, 2))])\n",
    "    pred = np.zeros(len(obs))\n",
    "    for j in range(len(obs)):\n",
    "        pred[j] = agent.select_action(obs[j]) - 100\n",
    "    prev_pos = pred\n",
    "    preds.append(pred)\n",
    "\n",
    "obs_input['holdings'] = np.concatenate(preds)\n",
    "obs_input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_input = obs_input.sort_values(['episode_idx', 'normalized_time'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_reward_vectorize(res):\n",
    "    res['delta_wealth'] = res['holdings'].shift() * res['price'] + 100 * res['call_price'] - (res['holdings'] * res['price'] + 100 * res['call_price']).shift()\n",
    "    res.loc[res['normalized_time']==res['normalized_time'].min(), 'delta_wealth'] = 0.\n",
    "    res['reward'] = res['delta_wealth'] ** 2 * -0.5 * 0.1\n",
    "    return res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs_input = calculate_reward_vectorize(obs_input)\n",
    "\n",
    "obs_input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_experiment = obs_input.query('episode_idx==99')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sample_experiment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, axes = plt.subplots(1, 2, figsize=(16, 8))\n",
    "axes[0].plot(np.arange(50), sample_experiment.delta * -100, '-')\n",
    "axes[0].plot(np.arange(50), sample_experiment.holdings, '*-')\n",
    "axes[1].plot(np.arange(50), ((sample_experiment['price'].shift(-1) - sample_experiment['price']) * sample_experiment['holdings']).cumsum(), 'v-')\n",
    "axes[1].plot(np.arange(50), ((sample_experiment['call_price'].shift(-1) - sample_experiment['call_price']) * 100).cumsum(), 'x-')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "my_env",
   "language": "python",
   "name": "my_env"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}