ml-finance-python

04_q_learning_for_trading.ipynb

(149551B)

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# Reinforcement Learning for trading"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To train a trading agent, we need to create a market environment that provides price and other information, offers trading-related actions, and keeps track of the portfolio to reward the agent accordingly."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## How to Design an OpenAI trading environment"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The OpenAI Gym allows for the design, registration, and utilization of environments that adhere to its architecture, as described in its [documentation](https://github.com/openai/gym/tree/master/gym/envs#how-to-create-new-environments-for-gym). The [trading_env.py](trading_env.py) file implements an example that illustrates how to create a class that implements the requisite `step()` and `reset()` methods.\n",
     "\n",
     "The trading environment consists of three classes that interact to facilitate the agent's activities:\n",
     " 1. The `DataSource` class loads a time series, generates a few features, and provides the latest observation to the agent at each time step. \n",
     " 2. `TradingSimulator` tracks the positions, trades and cost, and the performance. It also implements and records the results of a buy-and-hold benchmark strategy. \n",
     " 3. `TradingEnvironment` itself orchestrates the process. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## A basic trading game"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To train the agent, we need to set up a simple game with a limited set of options, a relatively low-dimensional state, and other parameters that can be easily modified and extended.\n",
     "\n",
     "More specifically, the environment samples a stock price time series for a single ticker using a random start date to simulate a trading period that, by default, contains 252 days, or 1 year. The state contains the (scaled) price and volume, as well as some technical indicators like the percentile ranks of price and volume, a relative strength index (RSI), as well as 5- and 21-day returns. The agent can choose from three actions:\n",
     "\n",
     "- **Buy**: Invest capital for a long position in the stock\n",
     "- **Flat**: Hold cash only\n",
     "- **Sell short**: Take a short position equal to the amount of capital\n",
     "\n",
     "The environment accounts for trading cost, which is set to 10bps by default. It also deducts a 1bps time cost per period. It tracks the net asset value (NAV) of the agent's portfolio and compares it against the market portfolio (which trades frictionless to raise the bar for the agent)."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We use the same DDQN agent and neural network architecture that successfully learned to navigate the Lunar Lander environment. We let exploration continue for 500,000 time steps (~2,000 1yr trading periods) with linear decay of ε to 0.1 and exponential decay at a factor of 0.9999 thereafter."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Imports & Settings"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
     "%matplotlib inline\n",
     "from pathlib import Path\n",
     "from collections import deque, namedtuple\n",
     "from time import time\n",
     "from random import sample\n",
     "import numpy as np\n",
     "from numpy.random import random, randint, seed\n",
     "import pandas as pd\n",
     "\n",
     "import matplotlib.pyplot as plt\n",
     "from matplotlib.ticker import FuncFormatter\n",
     "import seaborn as sns\n",
     "\n",
     "import tensorflow as tf\n",
     "\n",
     "import gym\n",
     "from gym.envs.registration import register"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "sns.set_style('darkgrid')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Helper functions"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
     "def format_time(t):\n",
     "    m_, s = divmod(t, 60)\n",
     "    h, m = divmod(m_, 60)\n",
     "    return '{:02.0f}:{:05.2f}'.format(m, s)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
     "def track_results(episode, episode_nav,\n",
     "                  market_nav, ratio,\n",
     "                  total,\n",
     "                  epsilon):\n",
     "    time_ma = np.mean([episode_time[-100:]])\n",
     "    T = np.sum(episode_time)\n",
     "\n",
     "    print('{:>4d} | NAV: {:>5.3f} | Market NAV: {:>5.3f} | Delta: {:4.0f} | {} | '\n",
     "          'eps: {:>6.3f}'.format(episode,\n",
     "                                  episode_nav,\n",
     "                                  market_nav,\n",
     "                                  ratio,\n",
     "                                  format_time(total),\n",
     "                                  epsilon))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Set up Gym Environment"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Before using the custom environment, just like we used the Lunar Lander environment, we need to register it:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "register(\n",
     "    id='trading-v0',\n",
     "    entry_point='trading_env:TradingEnvironment',\n",
     "    max_episode_steps=1000\n",
     ")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Initialize Trading Environment"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We can instantiate the environment by using the desired trading costs and ticker:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
       "INFO:trading_env:trading_env logger started.\n",
       "INFO:trading_env:loading data for AAPL...\n",
       "INFO:trading_env:got data for AAPL...\n",
       "INFO:trading_env:None\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "<class 'pandas.core.frame.DataFrame'>\n",
       "MultiIndex: 8596 entries, (1981-05-06 00:00:00, AAPL) to (2018-03-27 00:00:00, AAPL)\n",
       "Data columns (total 10 columns):\n",
       "close             8596 non-null float64\n",
       "volume            8596 non-null float64\n",
       "returns           8596 non-null float64\n",
       "close_pct_100     8596 non-null float64\n",
       "volume_pct_100    8596 non-null float64\n",
       "close_pct_20      8596 non-null float64\n",
       "volume_pct_20     8596 non-null float64\n",
       "return_5          8596 non-null float64\n",
       "return_21         8596 non-null float64\n",
       "rsi               8596 non-null float64\n",
       "dtypes: float64(10)\n",
       "memory usage: 841.8+ KB\n"
      ]
     },
     {
      "data": {
       "text/plain": [
        "[42]"
       ]
      },
      "execution_count": 7,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
     "trading_environment = gym.make('trading-v0')\n",
     "trading_environment.env.trading_cost_bps = 1e-3\n",
     "trading_environment.env.time_cost_bps = 1e-4\n",
     "trading_environment.env.ticker = 'AAPL'\n",
     "trading_environment.seed(42)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Get Environment Params"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
     "state_dim = trading_environment.observation_space.shape[0]  # number of dimensions in state\n",
     "n_actions = trading_environment.action_space.n  # number of actions\n",
     "max_episode_steps = trading_environment.spec.max_episode_steps  # max number of steps per episode"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Define hyperparameters"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
    "outputs": [],
    "source": [
     "gamma=.99,  # discount factor\n",
     "tau=100  # target network update frequency"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### NN Architecture"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {},
    "outputs": [],
    "source": [
     "layers=(256,) * 3  # units per layer\n",
     "learning_rate=5e-5  # learning rate\n",
     "l2_reg=1e-6  # L2 regularization"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Experience Replay"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
     "replay_capacity=int(1e6)\n",
     "minibatch_size=5"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### $\\epsilon$-greedy Policy"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
    "outputs": [],
    "source": [
     "epsilon_start=1.0\n",
     "epsilon_end=0.1\n",
     "epsilon_linear_steps=5e5\n",
     "epsilon_exp_decay=.9999"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Create Neural Network"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We will use [TensorFlow](https://www.tensorflow.org/) to create our Double Deep Q-Network ."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "tf.reset_default_graph()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Dense Layers"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The `create_network` function generates the three dense layers that can be trained and/or reused as required by the Q network and its slower-moving target network:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [],
    "source": [
     "def create_network(s, layers, trainable, reuse, n_actions=4):\n",
     "    \"\"\"Generate Q and target network with same structure\"\"\"\n",
     "    for layer, units in enumerate(layers):\n",
     "        x = tf.layers.dense(inputs=s if layer == 0 else x,\n",
     "                            units=units,\n",
     "                            activation=tf.nn.relu,\n",
     "                            trainable=trainable,\n",
     "                            reuse=reuse,\n",
     "                            name='dense_{}'.format(layer))\n",
     "    return tf.squeeze(tf.layers.dense(inputs=x,\n",
     "                                      units=n_actions,\n",
     "                                      trainable=trainable,\n",
     "                                      reuse=reuse,\n",
     "                                      name='output'))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Placeholders"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Key elements of the DDQN's computational graph include placeholder variables for the state, action, and reward sequences:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
     "state = tf.placeholder(dtype=tf.float32, shape=[None, state_dim])  # input to Q network\n",
     "next_state = tf.placeholder(dtype=tf.float32, shape=[None, state_dim])  # input to target network\n",
     "action = tf.placeholder(dtype=tf.int32, shape=[None])  # action indices (indices of Q network output)\n",
     "reward = tf.placeholder(dtype=tf.float32, shape=[None])  # rewards for target computation\n",
     "not_done = tf.placeholder(dtype=tf.float32, shape=[None])  # indicators for target computation"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Episode Counter"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We add a variable to keep track of episodes:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "episode_count = tf.Variable(0.0, trainable=False, name='episode_count')\n",
     "add_episode = episode_count.assign_add(1)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Deep Q Networks"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We will create two DQNs to predict q values for the current and next state, where we hold the weights for the second network that's fixed when predicting the next state:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "with tf.variable_scope('Q_Network'):\n",
     "    # Q network applied to current observation\n",
     "    q_action_values = create_network(state,\n",
     "                                     layers=layers,\n",
     "                                     trainable=True,\n",
     "                                     reuse=False)\n",
     "\n",
     "    # Q network applied to next_observation\n",
     "    next_q_action_values = tf.stop_gradient(create_network(next_state,\n",
     "                                                           layers=layers,\n",
     "                                                           trainable=False,\n",
     "                                                           reuse=True))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Slow-Moving Target Network"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "In addition, we will create the target network that we update every tau periods:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "with tf.variable_scope('Target_Network', reuse=False):\n",
     "    target_action_values = tf.stop_gradient(create_network(next_state,\n",
     "                                                           layers=layers,\n",
     "                                                           trainable=False,\n",
     "                                                           reuse=False))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Collect Variables and Operations"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To build TensorFlow's computational graph, we need to collect the relevant variables and operations:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "q_network_variables = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Q_Network')\n",
     "target_network_variables = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='Target_Network')\n",
     "\n",
     "# update target network weights\n",
     "update_target_ops = []\n",
     "for i, target_variable in enumerate(target_network_variables):\n",
     "    update_target_op = target_variable.assign(q_network_variables[i])\n",
     "    update_target_ops.append(update_target_op)\n",
     "update_target_op = tf.group(*update_target_ops, name='update_target')"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Compute Q-Learning updates"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The target, yi, and the predicted q value is computed as follows:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "# Q target calculation \n",
     "targets = reward + not_done * gamma * tf.gather_nd(target_action_values, tf.stack(\n",
     "                (tf.range(minibatch_size), tf.cast(tf.argmax(next_q_action_values, axis=1), tf.int32)), axis=1))\n",
     "\n",
     "\n",
     "# Estimated Q values for (s,a) from experience replay\n",
     "predicted_q_value = tf.gather_nd(q_action_values,\n",
     "                                 tf.stack((tf.range(minibatch_size),\n",
     "                                           action), axis=1))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Compute Loss Function"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "Finally, the TD loss function that's used for stochastic gradient descent is the mean squared error (MSE) between the target and prediction:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "losses = tf.squared_difference(targets, predicted_q_value)\n",
     "loss = tf.reduce_mean(losses)\n",
     "loss += tf.add_n([tf.nn.l2_loss(var) for var in q_network_variables if 'bias' not in var.name]) * l2_reg * 0.5"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Tensorboard summaries"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "To view results in [tensorboard](https://www.tensorflow.org/guide/summaries_and_tensorboard), we need to define summaries:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "summaries = tf.summary.merge([\n",
     "    tf.summary.scalar('episode', episode_count),\n",
     "    tf.summary.scalar('loss', loss),\n",
     "    tf.summary.scalar('max_q_value', tf.reduce_max(predicted_q_value)),\n",
     "    tf.summary.histogram('loss_hist', losses),\n",
     "    tf.summary.histogram('q_values', predicted_q_value)])"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Set optimizer"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "We'll use the [AdamOptimizer](https://www.tensorflow.org/api_docs/python/tf/train/AdamOptimizer):"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
     "train_op = tf.train.AdamOptimizer(learning_rate).minimize(loss,\n",
     "                                                          global_step=tf.train.create_global_step())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Initialize TensorFlow session"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "WARNING:tensorflow:From /home/stefan/.pyenv/versions/miniconda3-latest/envs/ml4t/lib/python3.6/site-packages/tensorflow/python/framework/op_def_library.py:263: colocate_with (from tensorflow.python.framework.ops) is deprecated and will be removed in a future version.\n",
       "Instructions for updating:\n",
       "Colocations handled automatically by placer.\n",
       "WARNING:tensorflow:From <ipython-input-7-178a7f73e60f>:9: dense (from tensorflow.python.layers.core) is deprecated and will be removed in a future version.\n",
       "Instructions for updating:\n",
       "Use keras.layers.dense instead.\n",
       "WARNING:tensorflow:From /home/stefan/.pyenv/versions/miniconda3-latest/envs/ml4t/lib/python3.6/site-packages/tensorflow/python/ops/math_ops.py:3066: to_int32 (from tensorflow.python.ops.math_ops) is deprecated and will be removed in a future version.\n",
       "Instructions for updating:\n",
       "Use tf.cast instead.\n"
      ]
     }
    ],
    "source": [
     "sess = tf.Session()\n",
     "sess.run(tf.global_variables_initializer())"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Run Experiment"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Set parameters"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {},
    "outputs": [],
    "source": [
     "total_steps, max_episodes = 0, 10000\n",
     "experience = deque(maxlen=replay_capacity)\n",
     "episode_time, navs, market_navs,diffs, episode_eps = [], [], [], [],[]"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Initialize variables"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 16,
    "metadata": {},
    "outputs": [],
    "source": [
     "experience = deque(maxlen=replay_capacity)\n",
     "episode_time, episode_steps, episode_rewards, episode_eps = [], [], [], []"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {},
    "outputs": [],
    "source": [
     "epsilon = epsilon_start\n",
     "epsilon_linear_step = (epsilon_start - epsilon_end) / epsilon_linear_steps"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Train Agent"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 23,
    "metadata": {
     "scrolled": false
    },
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "   0 | NAV: 0.534 | Market NAV: 1.836 | Delta:    0 | 00:00.47 | eps:  0.999\n",
       " 250 | NAV: 0.797 | Market NAV: 1.331 | Delta:   19 | 00:56.60 | eps:  0.886\n",
       " 500 | NAV: 0.774 | Market NAV: 1.253 | Delta:   23 | 01:55.27 | eps:  0.772\n",
       " 750 | NAV: 0.801 | Market NAV: 1.431 | Delta:   16 | 02:56.54 | eps:  0.659\n",
       "1000 | NAV: 0.849 | Market NAV: 1.406 | Delta:   26 | 04:07.49 | eps:  0.545\n",
       "1250 | NAV: 0.819 | Market NAV: 1.303 | Delta:   13 | 05:19.67 | eps:  0.432\n",
       "1500 | NAV: 0.974 | Market NAV: 1.297 | Delta:   29 | 06:31.60 | eps:  0.319\n",
       "1750 | NAV: 0.938 | Market NAV: 1.359 | Delta:   30 | 07:45.69 | eps:  0.205\n",
       "2000 | NAV: 1.081 | Market NAV: 1.403 | Delta:   25 | 09:02.94 | eps:  0.100\n",
       "2250 | NAV: 1.132 | Market NAV: 1.492 | Delta:   25 | 10:23.32 | eps:  0.097\n",
       "2500 | NAV: 1.014 | Market NAV: 1.324 | Delta:   21 | 11:46.05 | eps:  0.095\n",
       "2750 | NAV: 1.017 | Market NAV: 1.359 | Delta:   21 | 13:11.42 | eps:  0.093\n",
       "3000 | NAV: 1.089 | Market NAV: 1.275 | Delta:   35 | 14:39.76 | eps:  0.090\n",
       "3250 | NAV: 1.154 | Market NAV: 1.323 | Delta:   30 | 16:10.79 | eps:  0.088\n",
       "3500 | NAV: 1.184 | Market NAV: 1.315 | Delta:   37 | 17:44.59 | eps:  0.086\n",
       "3750 | NAV: 1.167 | Market NAV: 1.375 | Delta:   21 | 19:21.34 | eps:  0.084\n",
       "4000 | NAV: 1.184 | Market NAV: 1.385 | Delta:   29 | 21:03.62 | eps:  0.082\n",
       "4250 | NAV: 1.189 | Market NAV: 1.390 | Delta:   30 | 22:51.81 | eps:  0.080\n",
       "4500 | NAV: 1.272 | Market NAV: 1.372 | Delta:   33 | 24:41.07 | eps:  0.078\n",
       "4750 | NAV: 1.086 | Market NAV: 1.317 | Delta:   32 | 26:22.23 | eps:  0.076\n",
       "5000 | NAV: 1.202 | Market NAV: 1.379 | Delta:   36 | 28:08.88 | eps:  0.074\n",
       "5250 | NAV: 1.221 | Market NAV: 1.326 | Delta:   34 | 29:51.13 | eps:  0.072\n",
       "5500 | NAV: 1.207 | Market NAV: 1.284 | Delta:   33 | 31:32.27 | eps:  0.070\n",
       "5750 | NAV: 1.263 | Market NAV: 1.448 | Delta:   24 | 33:13.59 | eps:  0.069\n",
       "6000 | NAV: 1.198 | Market NAV: 1.306 | Delta:   42 | 34:54.84 | eps:  0.067\n",
       "6250 | NAV: 1.164 | Market NAV: 1.251 | Delta:   44 | 36:36.06 | eps:  0.065\n",
       "6500 | NAV: 1.276 | Market NAV: 1.412 | Delta:   37 | 38:17.27 | eps:  0.064\n",
       "6750 | NAV: 1.259 | Market NAV: 1.456 | Delta:   29 | 39:58.54 | eps:  0.062\n",
       "7000 | NAV: 1.139 | Market NAV: 1.302 | Delta:   30 | 41:39.79 | eps:  0.061\n",
       "7250 | NAV: 1.228 | Market NAV: 1.347 | Delta:   37 | 43:21.06 | eps:  0.059\n",
       "7500 | NAV: 1.129 | Market NAV: 1.264 | Delta:   37 | 45:02.75 | eps:  0.058\n",
       "7750 | NAV: 1.202 | Market NAV: 1.334 | Delta:   35 | 46:43.78 | eps:  0.056\n",
       "8000 | NAV: 1.174 | Market NAV: 1.333 | Delta:   31 | 48:27.57 | eps:  0.055\n",
       "8250 | NAV: 1.138 | Market NAV: 1.293 | Delta:   40 | 50:11.39 | eps:  0.053\n",
       "8500 | NAV: 1.300 | Market NAV: 1.392 | Delta:   44 | 51:57.41 | eps:  0.052\n",
       "8750 | NAV: 1.271 | Market NAV: 1.442 | Delta:   28 | 53:47.43 | eps:  0.051\n",
       "9000 | NAV: 1.291 | Market NAV: 1.458 | Delta:   43 | 55:30.47 | eps:  0.050\n",
       "9250 | NAV: 1.173 | Market NAV: 1.317 | Delta:   35 | 57:11.88 | eps:  0.048\n",
       "9500 | NAV: 1.139 | Market NAV: 1.338 | Delta:   33 | 58:54.60 | eps:  0.047\n",
       "9750 | NAV: 1.132 | Market NAV: 1.320 | Delta:   30 | 00:36.03 | eps:  0.046\n"
      ]
     }
    ],
    "source": [
     "for episode in range(max_episodes):\n",
     "    episode_start = time()\n",
     "    episode_reward = 0\n",
     "    episode_eps.append(epsilon)\n",
     "\n",
     "    # Initial state\n",
     "    this_observation = trading_environment.reset()\n",
     "    for episode_step in range(max_episode_steps):\n",
     "\n",
     "        # choose action according to epsilon-greedy policy wrt Q\n",
     "\n",
     "        if random() < epsilon:\n",
     "            src = 'eps'\n",
     "            selected_action = randint(n_actions)\n",
     "        else:\n",
     "            src = 'q'\n",
     "            q_s = sess.run(q_action_values,\n",
     "                           feed_dict={state: this_observation[None]})\n",
     "            selected_action = np.argmax(q_s)\n",
     "\n",
     "        next_observation, step_reward, done, _ = trading_environment.step(selected_action)\n",
     "        episode_reward += step_reward\n",
     "\n",
     "        # add to replay buffer\n",
     "        experience.append((this_observation,\n",
     "                           selected_action,\n",
     "                           step_reward,\n",
     "                           next_observation,\n",
     "                           0.0 if done else 1.0))\n",
     "\n",
     "        # update the target weights\n",
     "        if total_steps % tau == 0:\n",
     "            _ = sess.run(update_target_op)\n",
     "\n",
     "        # update weights using minibatch of (s,a,r,s') samples from experience\n",
     "        if len(experience) >= minibatch_size:\n",
     "            minibatch = map(np.array, zip(\n",
     "                *sample(experience, minibatch_size)))\n",
     "            states_batch, action_batch, reward_batch, next_states_batch, done_batch = minibatch\n",
     "\n",
     "            # do a train_op with required inputs\n",
     "            feed_dict = {\n",
     "                state: states_batch,\n",
     "                action: action_batch,\n",
     "                reward: reward_batch,\n",
     "                next_state: next_states_batch,\n",
     "                not_done: done_batch}\n",
     "            _ = sess.run([train_op],\n",
     "                         feed_dict=feed_dict)\n",
     "\n",
     "        this_observation = next_observation\n",
     "        total_steps += 1\n",
     "\n",
     "        # linearly decay epsilon from epsilon_start to epsilon_end for epsilon_linear_steps\n",
     "        if total_steps < epsilon_linear_steps:\n",
     "            epsilon -= epsilon_linear_step\n",
     "        # then exponentially decay every episode\n",
     "        elif done:\n",
     "            epsilon *= epsilon_exp_decay\n",
     "\n",
     "        if done:\n",
     "            # Increment episode counter\n",
     "            episode_, _ = sess.run([episode_count, add_episode])\n",
     "            break\n",
     "\n",
     "    episode_time.append(time()-episode_start)\n",
     "    result = trading_environment.env.sim.result()\n",
     "    final = result.iloc[-1]\n",
     "\n",
     "    nav = final.nav * (1 + final.strategy_return)\n",
     "    navs.append(nav)\n",
     "\n",
     "    market_nav = final.market_nav\n",
     "    market_navs.append(market_nav)\n",
     "\n",
     "    diff = nav - market_nav\n",
     "    diffs.append(diff)\n",
     "    if episode % 250 == 0:\n",
     "        track_results(episode,\n",
     "                      np.mean(navs[-100:]),\n",
     "                      np.mean(market_navs[-100:]),\n",
     "                      np.sum([s > 0 for s in diffs[-100:]]),\n",
     "                      sum(episode_time),\n",
     "                      epsilon)\n",
     "\n",
     "    if len(diffs) > 25 and all([r > 0 for r in diffs[-25:]]):\n",
     "        print(result.tail())\n",
     "        break\n",
     "\n",
     "trading_environment.close()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Store Results"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 27,
    "metadata": {},
    "outputs": [],
    "source": [
     "results = pd.DataFrame({'episode': list(range(1, episode + 2)),\n",
     "                        'nav': navs,\n",
     "                        'market_nav': market_navs,\n",
     "                        'outperform': diffs})\n",
     "\n",
     "fn = 'trading_agent_result_no_cost.csv'\n",
     "results.to_csv(fn, index=False)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "### Evaluate Results"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 34,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "<class 'pandas.core.frame.DataFrame'>\n",
       "Int64Index: 14039 entries, 1 to 14039\n",
       "Data columns (total 4 columns):\n",
       "Agent                14039 non-null float64\n",
       "Market               14039 non-null float64\n",
       "difference           14039 non-null float64\n",
       "Strategy Wins (%)    13940 non-null float64\n",
       "dtypes: float64(4)\n",
       "memory usage: 548.4 KB\n"
      ]
     }
    ],
    "source": [
     "results = pd.read_csv('trading_agent_result.csv')\n",
     "results.columns = ['Episode', 'Agent', 'Market', 'difference']\n",
     "results = results.set_index('Episode')\n",
     "results['Strategy Wins (%)'] = (results.difference > 0).rolling(100).sum()\n",
     "results.info()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "The following diagram shows the rolling average of agent and market returns over 100 periods on the left, and the share of the last 100 periods the agent outperformed the market on the right. It uses AAPL stock data for which there are some 9,000 daily price and volume observations. Training stopped after 14,000 trading periods when the agent beat the market 10 consecutive times.\n",
     "\n",
     "It shows how the agent's performance improves significantly while exploring at a higher rate over the first ~3,000 periods (that is, years) and approaches a level where it outperforms the market around 40 percent of the time, despite transaction costs. In a few instances, it beats the market about half the time out of 100 periods:"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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\n",
       "text/plain": [
        "<Figure size 1008x288 with 2 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "fig, axes = plt.subplots(ncols=2, figsize=(14,4))\n",
     "(results[['Agent', 'Market']]\n",
     " .sub(1)\n",
     " .rolling(100)\n",
     " .mean()\n",
     " .plot(ax=axes[0], \n",
     "       title='Annual Returns (Moving Average)', lw=1))\n",
     "results['Strategy Wins (%)'].div(100).rolling(50).mean().plot(ax=axes[1], title='Agent Outperformance (%, Moving Average)');\n",
     "for ax in axes:\n",
     "    ax.yaxis.set_major_formatter(FuncFormatter(lambda y, _: '{:.0%}'.format(y)))\n",
     "    ax.xaxis.set_major_formatter(FuncFormatter(lambda x, _: '{:,.0f}'.format(x)))\n",
     "fig.tight_layout()\n",
     "# fig.savefig('figures/trading_agent', dpi=300)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## Summary"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "This relatively simple agent uses limited information beyond the latest market data and the reward signal compared to the machine learning models we covered elsewhere in this book. Nonetheless, it learns to make a profit and approach the market (after training on several thousand year's worth of data, which takes around 30 minutes).\n",
     "\n",
     "Keep in mind that using a single stock also increase the risk of overfitting the data by a lot. You can test your trained agent on new data using the saved model (see the notebook on the Lunar Lander).\n",
     "\n",
     "In conclusion, we have demonstrated the mechanics of setting up a RL trading environment and experimented with a basic agent that uses a small number of technical indicators. You should try to extend both the environment and the agent so that you can choose from several assets, size their positions, and manage risks.\n",
     "\n",
     "More specifically, the environment samples a stock price time series for a single ticker from a random start date to simulate a trading period of 252 days, or 1 year (default). The agent has three options, that is, buying (long), short, or exiting its position, and faces a 10bps trading plus a 1bps time cost per period."
    ]
   },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
   "language_info": {
    "codemirror_mode": {
     "name": "ipython",
     "version": 3
    },
    "file_extension": ".py",
    "mimetype": "text/x-python",
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
    "version": "3.6.8"
   },
   "toc": {
    "base_numbering": 1,
    "nav_menu": {},
    "number_sections": true,
    "sideBar": true,
    "skip_h1_title": true,
    "title_cell": "Table of Contents",
    "title_sidebar": "Contents",
    "toc_cell": false,
    "toc_position": {
     "height": "calc(100% - 180px)",
     "left": "10px",
     "top": "150px",
     "width": "230.909px"
    },
    "toc_section_display": true,
    "toc_window_display": true
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }