agent/17.actor-critic-duel-recurrent-agent.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tensorflow as tf\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "sns.set()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "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>Date</th>\n",
       "      <th>Open</th>\n",
       "      <th>High</th>\n",
       "      <th>Low</th>\n",
       "      <th>Close</th>\n",
       "      <th>Adj Close</th>\n",
       "      <th>Volume</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2016-11-02</td>\n",
       "      <td>778.200012</td>\n",
       "      <td>781.650024</td>\n",
       "      <td>763.450012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>768.700012</td>\n",
       "      <td>1872400</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2016-11-03</td>\n",
       "      <td>767.250000</td>\n",
       "      <td>769.950012</td>\n",
       "      <td>759.030029</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>762.130005</td>\n",
       "      <td>1943200</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2016-11-04</td>\n",
       "      <td>750.659973</td>\n",
       "      <td>770.359985</td>\n",
       "      <td>750.560974</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>762.020020</td>\n",
       "      <td>2134800</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2016-11-07</td>\n",
       "      <td>774.500000</td>\n",
       "      <td>785.190002</td>\n",
       "      <td>772.549988</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>782.520020</td>\n",
       "      <td>1585100</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2016-11-08</td>\n",
       "      <td>783.400024</td>\n",
       "      <td>795.632996</td>\n",
       "      <td>780.190002</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>790.510010</td>\n",
       "      <td>1350800</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "         Date        Open        High         Low       Close   Adj Close  \\\n",
       "0  2016-11-02  778.200012  781.650024  763.450012  768.700012  768.700012   \n",
       "1  2016-11-03  767.250000  769.950012  759.030029  762.130005  762.130005   \n",
       "2  2016-11-04  750.659973  770.359985  750.560974  762.020020  762.020020   \n",
       "3  2016-11-07  774.500000  785.190002  772.549988  782.520020  782.520020   \n",
       "4  2016-11-08  783.400024  795.632996  780.190002  790.510010  790.510010   \n",
       "\n",
       "    Volume  \n",
       "0  1872400  \n",
       "1  1943200  \n",
       "2  2134800  \n",
       "3  1585100  \n",
       "4  1350800  "
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df = pd.read_csv('../dataset/GOOG-year.csv')\n",
    "df.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class Actor:\n",
    "    def __init__(self, name, input_size, output_size, size_layer):\n",
    "        with tf.variable_scope(name):\n",
    "            self.X = tf.placeholder(tf.float32, (None, None, input_size))\n",
    "            self.hidden_layer = tf.placeholder(tf.float32, (None, 2 * size_layer))\n",
    "            cell = tf.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple = False)\n",
    "            self.rnn,self.last_state = tf.nn.dynamic_rnn(inputs=self.X, cell=cell,\n",
    "                                                    dtype=tf.float32,\n",
    "                                                    initial_state=self.hidden_layer)\n",
    "            tensor_action, tensor_validation = tf.split(self.rnn[:,-1],2,1)\n",
    "            feed_action = tf.layers.dense(tensor_action, output_size)\n",
    "            feed_validation = tf.layers.dense(tensor_validation, 1)\n",
    "            self.logits = feed_validation + tf.subtract(feed_action,\n",
    "                                                        tf.reduce_mean(feed_action,axis=1,keep_dims=True))\n",
    "\n",
    "class Critic:\n",
    "    def __init__(self, name, input_size, output_size, size_layer, learning_rate):\n",
    "        with tf.variable_scope(name):\n",
    "            self.X = tf.placeholder(tf.float32, (None, None, input_size))\n",
    "            self.Y = tf.placeholder(tf.float32, (None, output_size))\n",
    "            self.hidden_layer = tf.placeholder(tf.float32, (None, 2 * size_layer))\n",
    "            self.REWARD = tf.placeholder(tf.float32, (None, 1))\n",
    "            feed_critic = tf.layers.dense(self.X, size_layer, activation = tf.nn.relu)\n",
    "            cell = tf.nn.rnn_cell.LSTMCell(size_layer, state_is_tuple = False)\n",
    "            self.rnn,self.last_state = tf.nn.dynamic_rnn(inputs=self.X, cell=cell,\n",
    "                                                    dtype=tf.float32,\n",
    "                                                    initial_state=self.hidden_layer)\n",
    "            tensor_action, tensor_validation = tf.split(self.rnn[:,-1],2,1)\n",
    "            feed_action = tf.layers.dense(tensor_action, output_size)\n",
    "            feed_validation = tf.layers.dense(tensor_validation, 1)\n",
    "            feed_critic = feed_validation + tf.subtract(feed_action,tf.reduce_mean(feed_action,axis=1,keep_dims=True))\n",
    "            feed_critic = tf.nn.relu(feed_critic) + self.Y\n",
    "            feed_critic = tf.layers.dense(feed_critic, size_layer//2, activation = tf.nn.relu)\n",
    "            self.logits = tf.layers.dense(feed_critic, 1)\n",
    "            self.cost = tf.reduce_mean(tf.square(self.REWARD - self.logits))\n",
    "            self.optimizer = tf.train.AdamOptimizer(learning_rate).minimize(self.cost)\n",
    "            \n",
    "class Agent:\n",
    "\n",
    "    LEARNING_RATE = 0.001\n",
    "    BATCH_SIZE = 32\n",
    "    LAYER_SIZE = 256\n",
    "    OUTPUT_SIZE = 3\n",
    "    EPSILON = 0.5\n",
    "    DECAY_RATE = 0.005\n",
    "    MIN_EPSILON = 0.1\n",
    "    GAMMA = 0.99\n",
    "    MEMORIES = deque()\n",
    "    MEMORY_SIZE = 300\n",
    "    COPY = 1000\n",
    "    T_COPY = 0\n",
    "\n",
    "    def __init__(self, state_size, window_size, trend, skip):\n",
    "        self.state_size = state_size\n",
    "        self.window_size = window_size\n",
    "        self.half_window = window_size // 2\n",
    "        self.trend = trend\n",
    "        self.INITIAL_FEATURES = np.zeros((4, self.state_size))\n",
    "        self.skip = skip\n",
    "        tf.reset_default_graph()\n",
    "        self.actor = Actor('actor-original', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE)\n",
    "        self.actor_target = Actor('actor-target', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE)\n",
    "        self.critic = Critic('critic-original', self.state_size, self.OUTPUT_SIZE, self.LAYER_SIZE, self.LEARNING_RATE)\n",
    "        self.critic_target = Critic('critic-target', self.state_size, self.OUTPUT_SIZE, \n",
    "                                    self.LAYER_SIZE, self.LEARNING_RATE)\n",
    "        self.grad_critic = tf.gradients(self.critic.logits, self.critic.Y)\n",
    "        self.actor_critic_grad = tf.placeholder(tf.float32, [None, self.OUTPUT_SIZE])\n",
    "        weights_actor = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='actor')\n",
    "        self.grad_actor = tf.gradients(self.actor.logits, weights_actor, -self.actor_critic_grad)\n",
    "        grads = zip(self.grad_actor, weights_actor)\n",
    "        self.optimizer = tf.train.AdamOptimizer(self.LEARNING_RATE).apply_gradients(grads)\n",
    "        self.sess = tf.InteractiveSession()\n",
    "        self.sess.run(tf.global_variables_initializer())\n",
    "    \n",
    "    def _assign(self, from_name, to_name):\n",
    "        from_w = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=from_name)\n",
    "        to_w = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope=to_name)\n",
    "        for i in range(len(from_w)):\n",
    "            assign_op = to_w[i].assign(from_w[i])\n",
    "            self.sess.run(assign_op)\n",
    "            \n",
    "    def _memorize(self, state, action, reward, new_state, dead, rnn_state):\n",
    "        self.MEMORIES.append((state, action, reward, new_state, dead, rnn_state))\n",
    "        if len(self.MEMORIES) > self.MEMORY_SIZE:\n",
    "            self.MEMORIES.popleft()\n",
    "            \n",
    "    def _select_action(self, state):\n",
    "        if np.random.rand() < self.EPSILON:\n",
    "            action = np.random.randint(self.OUTPUT_SIZE)\n",
    "        else:\n",
    "            prediction = self.sess.run(self.actor.logits, feed_dict={self.actor.X:[state]})[0]\n",
    "            action = np.argmax(prediction)\n",
    "        return action\n",
    "    \n",
    "    def _construct_memories_and_train(self, replay):\n",
    "        states = np.array([a[0] for a in replay])\n",
    "        new_states = np.array([a[3] for a in replay])\n",
    "        init_values = np.array([a[-1] for a in replay])\n",
    "        Q = self.sess.run(self.actor.logits, feed_dict={self.actor.X: states,\n",
    "                                                       self.actor.hidden_layer: init_values})\n",
    "        Q_target = self.sess.run(self.actor_target.logits, feed_dict={self.actor_target.X: states,\n",
    "                                                                     self.actor_target.hidden_layer: init_values})\n",
    "        grads = self.sess.run(self.grad_critic, feed_dict={self.critic.X:states, self.critic.Y:Q,\n",
    "                                                          self.critic.hidden_layer: init_values})[0]\n",
    "        self.sess.run(self.optimizer, feed_dict={self.actor.X:states, self.actor_critic_grad:grads,\n",
    "                                                self.actor.hidden_layer: init_values})\n",
    "        \n",
    "        rewards = np.array([a[2] for a in replay]).reshape((-1, 1))\n",
    "        rewards_target = self.sess.run(self.critic_target.logits, \n",
    "                                       feed_dict={self.critic_target.X:new_states,self.critic_target.Y:Q_target,\n",
    "                                                 self.critic_target.hidden_layer: init_values})\n",
    "        for i in range(len(replay)):\n",
    "            if not replay[0][-2]:\n",
    "                rewards[i] += self.GAMMA * rewards_target[i]\n",
    "        cost, _ = self.sess.run([self.critic.cost, self.critic.optimizer], \n",
    "                                feed_dict={self.critic.X:states, self.critic.Y:Q, self.critic.REWARD:rewards,\n",
    "                                          self.critic.hidden_layer: init_values})\n",
    "        return cost\n",
    "    \n",
    "    def get_state(self, t):\n",
    "        window_size = self.window_size + 1\n",
    "        d = t - window_size + 1\n",
    "        block = self.trend[d : t + 1] if d >= 0 else -d * [self.trend[0]] + self.trend[0 : t + 1]\n",
    "        res = []\n",
    "        for i in range(window_size - 1):\n",
    "            res.append(block[i + 1] - block[i])\n",
    "        return np.array(res)\n",
    "    \n",
    "    def buy(self, initial_money):\n",
    "        starting_money = initial_money\n",
    "        states_sell = []\n",
    "        states_buy = []\n",
    "        inventory = []\n",
    "        state = self.get_state(0)\n",
    "        init_value = np.zeros((1, 2 * self.LAYER_SIZE))\n",
    "        for k in range(self.INITIAL_FEATURES.shape[0]):\n",
    "            self.INITIAL_FEATURES[k,:] = state\n",
    "        for t in range(0, len(self.trend) - 1, self.skip):\n",
    "            \n",
    "            if np.random.rand() < self.EPSILON:\n",
    "                action = np.random.randint(self.OUTPUT_SIZE)\n",
    "            else:\n",
    "                action, last_state = self.sess.run([self.actor.logits,\n",
    "                                                  self.actor.last_state],\n",
    "                                                  feed_dict={self.actor.X:[self.INITIAL_FEATURES],\n",
    "                                                             self.actor.hidden_layer:init_value})\n",
    "                action, init_value = np.argmax(action[0]), last_state\n",
    "                    \n",
    "            next_state = self.get_state(t + 1)\n",
    "            \n",
    "            if action == 1 and initial_money >= self.trend[t]:\n",
    "                inventory.append(self.trend[t])\n",
    "                initial_money -= self.trend[t]\n",
    "                states_buy.append(t)\n",
    "                print('day %d: buy 1 unit at price %f, total balance %f'% (t, self.trend[t], initial_money))\n",
    "            \n",
    "            elif action == 2 and len(inventory):\n",
    "                bought_price = inventory.pop(0)\n",
    "                initial_money += self.trend[t]\n",
    "                states_sell.append(t)\n",
    "                try:\n",
    "                    invest = ((close[t] - bought_price) / bought_price) * 100\n",
    "                except:\n",
    "                    invest = 0\n",
    "                print(\n",
    "                    'day %d, sell 1 unit at price %f, investment %f %%, total balance %f,'\n",
    "                    % (t, close[t], invest, initial_money)\n",
    "                )\n",
    "            \n",
    "            new_state = np.append([self.get_state(t + 1)], self.INITIAL_FEATURES[:3, :], axis = 0)\n",
    "            self.INITIAL_FEATURES = new_state\n",
    "        invest = ((initial_money - starting_money) / starting_money) * 100\n",
    "        total_gains = initial_money - starting_money\n",
    "        return states_buy, states_sell, total_gains, invest\n",
    "    \n",
    "    def train(self, iterations, checkpoint, initial_money):\n",
    "        for i in range(iterations):\n",
    "            total_profit = 0\n",
    "            inventory = []\n",
    "            state = self.get_state(0)\n",
    "            starting_money = initial_money\n",
    "            init_value = np.zeros((1, 2 * self.LAYER_SIZE))\n",
    "            for k in range(self.INITIAL_FEATURES.shape[0]):\n",
    "                self.INITIAL_FEATURES[k,:] = state\n",
    "            for t in range(0, len(self.trend) - 1, self.skip):\n",
    "                if (self.T_COPY + 1) % self.COPY == 0:\n",
    "                    self._assign('actor-original', 'actor-target')\n",
    "                    self._assign('critic-original', 'critic-target')\n",
    "                    \n",
    "                if np.random.rand() < self.EPSILON:\n",
    "                    action = np.random.randint(self.OUTPUT_SIZE)\n",
    "                else:\n",
    "                    action, last_state = self.sess.run([self.actor.logits,\n",
    "                                                  self.actor.last_state],\n",
    "                                                  feed_dict={self.actor.X:[self.INITIAL_FEATURES],\n",
    "                                                             self.actor.hidden_layer:init_value})\n",
    "                    action, init_value = np.argmax(action[0]), last_state\n",
    "                \n",
    "                next_state = self.get_state(t + 1)\n",
    "                \n",
    "                if action == 1 and starting_money >= self.trend[t]:\n",
    "                    inventory.append(self.trend[t])\n",
    "                    starting_money -= self.trend[t]\n",
    "                \n",
    "                elif action == 2 and len(inventory) > 0:\n",
    "                    bought_price = inventory.pop(0)\n",
    "                    total_profit += self.trend[t] - bought_price\n",
    "                    starting_money += self.trend[t]\n",
    "                    \n",
    "                invest = ((starting_money - initial_money) / initial_money)\n",
    "                new_state = np.append([self.get_state(t + 1)], self.INITIAL_FEATURES[:3, :], axis = 0)\n",
    "                self._memorize(self.INITIAL_FEATURES, action, invest, new_state, \n",
    "                               starting_money < initial_money, init_value[0])\n",
    "                batch_size = min(len(self.MEMORIES), self.BATCH_SIZE)\n",
    "                self.INITIAL_FEATURES = new_state\n",
    "                replay = random.sample(self.MEMORIES, batch_size)\n",
    "                cost = self._construct_memories_and_train(replay)\n",
    "                self.T_COPY += 1\n",
    "                self.EPSILON = self.MIN_EPSILON + (1.0 - self.MIN_EPSILON) * np.exp(-self.DECAY_RATE * i)\n",
    "            if (i+1) % checkpoint == 0:\n",
    "                print('epoch: %d, total rewards: %f.3, cost: %f, total money: %f'%(i + 1, total_profit, cost,\n",
    "                                                                                  starting_money))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING:tensorflow:<tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f8ac3f890b8>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "WARNING:tensorflow:From <ipython-input-3-b82c6dfdfdbf>:17: calling reduce_mean (from tensorflow.python.ops.math_ops) with keep_dims is deprecated and will be removed in a future version.\n",
      "Instructions for updating:\n",
      "keep_dims is deprecated, use keepdims instead\n",
      "WARNING:tensorflow:<tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f8a4343d2b0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "WARNING:tensorflow:<tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f8a42e484e0>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "WARNING:tensorflow:<tensorflow.python.ops.rnn_cell_impl.LSTMCell object at 0x7f8a42670c50>: Using a concatenated state is slower and will soon be deprecated.  Use state_is_tuple=True.\n",
      "epoch: 10, total rewards: 1217.199710.3, cost: 0.428947, total money: 9258.459720\n",
      "epoch: 20, total rewards: 154.669988.3, cost: 0.205311, total money: 8167.020025\n",
      "epoch: 30, total rewards: 225.259892.3, cost: 0.080974, total money: 10225.259892\n",
      "epoch: 40, total rewards: 1857.994754.3, cost: 0.147440, total money: 7906.464724\n",
      "epoch: 50, total rewards: 864.365355.3, cost: 0.133079, total money: 3145.525327\n",
      "epoch: 60, total rewards: 252.179754.3, cost: 0.349886, total money: 10252.179754\n",
      "epoch: 70, total rewards: 2285.265256.3, cost: 0.122869, total money: 841.845272\n",
      "epoch: 80, total rewards: 2273.160095.3, cost: 0.042144, total money: 1779.580078\n",
      "epoch: 90, total rewards: 695.794921.3, cost: 0.652829, total money: 10695.794921\n",
      "epoch: 100, total rewards: -63.870359.3, cost: 0.026901, total money: 9936.129641\n",
      "epoch: 110, total rewards: 1660.049986.3, cost: 0.050525, total money: 236.529905\n",
      "epoch: 120, total rewards: 2137.930355.3, cost: 0.019048, total money: 635.270319\n",
      "epoch: 130, total rewards: 1263.700071.3, cost: 0.105621, total money: 836.610044\n",
      "epoch: 140, total rewards: 2582.234985.3, cost: 0.026973, total money: 1985.844970\n",
      "epoch: 150, total rewards: 1342.129822.3, cost: 0.045669, total money: 1933.479859\n",
      "epoch: 160, total rewards: 171.394838.3, cost: 0.186082, total money: 9198.064821\n",
      "epoch: 170, total rewards: 581.185307.3, cost: 0.243257, total money: 26.655338\n",
      "epoch: 180, total rewards: 109.954956.3, cost: 0.001933, total money: 9092.844971\n",
      "epoch: 190, total rewards: -85.549868.3, cost: 0.004746, total money: 9914.450132\n",
      "epoch: 200, total rewards: 94.994872.3, cost: 0.006849, total money: 10094.994872\n"
     ]
    }
   ],
   "source": [
    "close = df.Close.values.tolist()\n",
    "initial_money = 10000\n",
    "window_size = 30\n",
    "skip = 1\n",
    "batch_size = 32\n",
    "agent = Agent(state_size = window_size, \n",
    "              window_size = window_size, \n",
    "              trend = close, \n",
    "              skip = skip)\n",
    "agent.train(iterations = 200, checkpoint = 10, initial_money = initial_money)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "day 0: buy 1 unit at price 768.700012, total balance 9231.299988\n",
      "day 1, sell 1 unit at price 762.130005, investment -0.854691 %, total balance 9993.429993,\n",
      "day 3: buy 1 unit at price 782.520020, total balance 9210.909973\n",
      "day 4, sell 1 unit at price 790.510010, investment 1.021059 %, total balance 10001.419983,\n",
      "day 22: buy 1 unit at price 762.520020, total balance 9238.899963\n",
      "day 23: buy 1 unit at price 759.109985, total balance 8479.789978\n",
      "day 24, sell 1 unit at price 771.190002, investment 1.137017 %, total balance 9250.979980,\n",
      "day 26, sell 1 unit at price 789.289978, investment 3.975708 %, total balance 10040.269958,\n",
      "day 31: buy 1 unit at price 790.799988, total balance 9249.469970\n",
      "day 32, sell 1 unit at price 794.200012, investment 0.429947 %, total balance 10043.669982,\n",
      "day 33: buy 1 unit at price 796.419983, total balance 9247.249999\n",
      "day 34, sell 1 unit at price 794.559998, investment -0.233543 %, total balance 10041.809997,\n",
      "day 39: buy 1 unit at price 782.789978, total balance 9259.020019\n",
      "day 40: buy 1 unit at price 771.820007, total balance 8487.200012\n",
      "day 42, sell 1 unit at price 786.900024, investment 0.525051 %, total balance 9274.100036,\n",
      "day 45, sell 1 unit at price 806.650024, investment 4.512712 %, total balance 10080.750060,\n",
      "day 64: buy 1 unit at price 801.340027, total balance 9279.410033\n",
      "day 65, sell 1 unit at price 806.969971, investment 0.702566 %, total balance 10086.380004,\n",
      "day 68: buy 1 unit at price 813.669983, total balance 9272.710021\n",
      "day 70, sell 1 unit at price 820.450012, investment 0.833265 %, total balance 10093.160033,\n",
      "day 103: buy 1 unit at price 838.549988, total balance 9254.610045\n",
      "day 104, sell 1 unit at price 834.570007, investment -0.474627 %, total balance 10089.180052,\n",
      "day 110: buy 1 unit at price 824.320007, total balance 9264.860045\n",
      "day 111, sell 1 unit at price 823.559998, investment -0.092198 %, total balance 10088.420043,\n",
      "day 114: buy 1 unit at price 838.210022, total balance 9250.210021\n",
      "day 115, sell 1 unit at price 841.650024, investment 0.410399 %, total balance 10091.860045,\n",
      "day 128: buy 1 unit at price 932.169983, total balance 9159.690062\n",
      "day 129: buy 1 unit at price 928.780029, total balance 8230.910033\n",
      "day 131, sell 1 unit at price 932.219971, investment 0.005363 %, total balance 9163.130004,\n",
      "day 132, sell 1 unit at price 937.080017, investment 0.893644 %, total balance 10100.210021,\n",
      "day 144: buy 1 unit at price 966.950012, total balance 9133.260009\n",
      "day 145, sell 1 unit at price 975.599976, investment 0.894562 %, total balance 10108.859985,\n",
      "day 148: buy 1 unit at price 980.940002, total balance 9127.919983\n",
      "day 149, sell 1 unit at price 983.409973, investment 0.251796 %, total balance 10111.329956,\n",
      "day 151: buy 1 unit at price 942.900024, total balance 9168.429932\n",
      "day 153, sell 1 unit at price 950.760010, investment 0.833597 %, total balance 10119.189942,\n",
      "day 168: buy 1 unit at price 906.690002, total balance 9212.499940\n",
      "day 169, sell 1 unit at price 918.590027, investment 1.312469 %, total balance 10131.089967,\n",
      "day 171: buy 1 unit at price 930.090027, total balance 9200.999940\n",
      "day 172, sell 1 unit at price 943.830017, investment 1.477275 %, total balance 10144.829957,\n",
      "day 175: buy 1 unit at price 953.419983, total balance 9191.409974\n",
      "day 176, sell 1 unit at price 965.400024, investment 1.256533 %, total balance 10156.809998,\n",
      "day 178: buy 1 unit at price 968.150024, total balance 9188.659974\n",
      "day 179, sell 1 unit at price 972.919983, investment 0.492688 %, total balance 10161.579957,\n",
      "day 192: buy 1 unit at price 922.900024, total balance 9238.679933\n",
      "day 193, sell 1 unit at price 907.239990, investment -1.696829 %, total balance 10145.919923,\n",
      "day 194: buy 1 unit at price 914.390015, total balance 9231.529908\n",
      "day 196: buy 1 unit at price 922.219971, total balance 8309.309937\n",
      "day 197, sell 1 unit at price 926.960022, investment 1.374688 %, total balance 9236.269959,\n",
      "day 198, sell 1 unit at price 910.979980, investment -1.218797 %, total balance 10147.249939,\n",
      "day 207: buy 1 unit at price 929.570007, total balance 9217.679932\n",
      "day 208: buy 1 unit at price 939.330017, total balance 8278.349915\n",
      "day 209, sell 1 unit at price 937.340027, investment 0.835872 %, total balance 9215.689942,\n",
      "day 210, sell 1 unit at price 928.450012, investment -1.158273 %, total balance 10144.139954,\n",
      "day 211: buy 1 unit at price 927.809998, total balance 9216.329956\n",
      "day 212, sell 1 unit at price 935.950012, investment 0.877336 %, total balance 10152.279968,\n",
      "day 214: buy 1 unit at price 929.080017, total balance 9223.199951\n",
      "day 215, sell 1 unit at price 932.070007, investment 0.321823 %, total balance 10155.269958,\n",
      "day 226: buy 1 unit at price 944.489990, total balance 9210.779968\n",
      "day 227, sell 1 unit at price 949.500000, investment 0.530446 %, total balance 10160.279968,\n",
      "day 233: buy 1 unit at price 978.890015, total balance 9181.389953\n",
      "day 234, sell 1 unit at price 977.000000, investment -0.193077 %, total balance 10158.389953,\n",
      "day 243: buy 1 unit at price 988.200012, total balance 9170.189941\n",
      "day 244, sell 1 unit at price 968.450012, investment -1.998583 %, total balance 10138.639953,\n"
     ]
    }
   ],
   "source": [
    "states_buy, states_sell, total_gains, invest = agent.buy(initial_money = initial_money)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize = (15,5))\n",
    "plt.plot(close, color='r', lw=2.)\n",
    "plt.plot(close, '^', markersize=10, color='m', label = 'buying signal', markevery = states_buy)\n",
    "plt.plot(close, 'v', markersize=10, color='k', label = 'selling signal', markevery = states_sell)\n",
    "plt.title('total gains %f, total investment %f%%'%(total_gains, invest))\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "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"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}