backtest.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "import random\n",
    "import math\n",
    "import json\n",
    "from torch.autograd import Variable\n",
    "from torch.distributions import Categorical\n",
    "from utils.qf_data import normalize,load_observations\n",
    "from tools.ddpg.replay_buffer import ReplayBuffer\n",
    "from tools.ddpg.ornstein_uhlenbeck import OrnsteinUhlenbeckActionNoise\n",
    "import tensorflow as tf\n",
    "from tensorboardX import SummaryWriter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"0\"\n",
    "C_CUDA = torch.cuda.is_available()\n",
    "\n",
    "def obs_normalizer(observation):\n",
    "    # Normalize the observation into close/open ratio\n",
    "    if isinstance(observation, tuple):\n",
    "        observation = observation[0]\n",
    "    \n",
    "    observation = observation[:, :, 3:4] / observation[:, :, 0:1]\n",
    "    observation = normalize(observation)\n",
    "    return observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define actor network--CNN\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self,product_num, win_size):\n",
    "        super(Actor, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(\n",
    "            in_channels =  1,\n",
    "            out_channels = 32,\n",
    "            kernel_size = (1,3),\n",
    "            #stride = (1,3)\n",
    "        )\n",
    "        self.conv2 = nn.Conv2d(\n",
    "            in_channels = 32,\n",
    "            out_channels = 32,\n",
    "            kernel_size = (1, win_size-2),\n",
    "            #stride = (1, win_size-2)\n",
    "        )\n",
    "        self.linear1 = nn.Linear((product_num + 1)*1*32, 64)\n",
    "        self.linear2 = nn.Linear(64, 64)\n",
    "        self.linear3 = nn.Linear(64,product_num + 1)\n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        self.linear1.weight.data.uniform_(*hidden_init(self.linear1))\n",
    "        self.linear2.weight.data.uniform_(*hidden_init(self.linear2))\n",
    "        self.linear3.weight.data.uniform_(-3e-3, 3e-3)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        conv1_out = self.conv1(state)\n",
    "        conv1_out = F.relu(conv1_out)\n",
    "        conv2_out = self.conv2(conv1_out)\n",
    "        conv2_out = F.relu(conv2_out)\n",
    "        # Flatten\n",
    "        conv2_out = conv2_out.view(conv2_out.size(0), -1)\n",
    "        fc1_out = self.linear1(conv2_out)\n",
    "        fc1_out = F.relu(fc1_out)\n",
    "        fc2_out = self.linear2(fc1_out)\n",
    "        fc2_out = F.relu(fc2_out)\n",
    "        fc3_out = self.linear3(fc2_out)\n",
    "        fc3_out = F.softmax(fc3_out,dim=1)\n",
    "        \n",
    "        return fc3_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define policy gradient actor network--LSTM\n",
    "class Policy(nn.Module):\n",
    "    def __init__(self,product_num, win_size,action_size):\n",
    "        super(Policy, self).__init__()\n",
    "        \n",
    "        self.lstm = nn.LSTM(win_size,32,1)\n",
    "        \n",
    "        self.linear1 = nn.Linear((product_num+1)*1*32, 64)\n",
    "        self.linear2 = nn.Linear(64, 64)\n",
    "        self.linear3 = nn.Linear(64,action_size)\n",
    "        \n",
    "        # Define the  vars for recording log prob and reawrd\n",
    "        self.saved_log_probs = []\n",
    "        self.rewards = []\n",
    "        \n",
    "    \n",
    "    def reset_parameters(self):\n",
    "        self.linear1.weight.data.uniform_(*hidden_init(self.linear1))\n",
    "        self.linear2.weight.data.uniform_(*hidden_init(self.linear2))\n",
    "        self.linear3.weight.data.uniform_(-3e-3, 3e-3)\n",
    "    \n",
    "    def forward(self, state):\n",
    "        state = torch.reshape(state, (-1, 1, 3))\n",
    "        lstm_out, _ = self.lstm(state)\n",
    "        batch_n,win_s,hidden_s = lstm_out.shape\n",
    "        lstm_out = lstm_out.view(batch_n, win_s*hidden_s)\n",
    "        lstm_out = torch.reshape(lstm_out, (-1, product_num+1, 32))\n",
    "        lstm_out = lstm_out.view(lstm_out.size(0), -1)\n",
    "        fc1_out = self.linear1(lstm_out)\n",
    "        #fc1_out = F.relu(fc1_out)\n",
    "        fc2_out = self.linear2(fc1_out)\n",
    "        #fc2_out = F.relu(fc2_out)\n",
    "        fc3_out = self.linear3(fc2_out)\n",
    "        fc3_out = F.softmax(fc3_out,dim=1)\n",
    "        \n",
    "        return fc3_out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "from environment.QF_env_2 import envs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_add = 'models/'\n",
    "model_name = 'QFPIS_DDPG_2'\n",
    "pg_model_name = 'QFPIS_PG_2'\n",
    "product_num =9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_actor():\n",
    "    actor = Actor(product_num =9,win_size = 3).cuda()\n",
    "    actor.load_state_dict(torch.load(model_add+model_name))\n",
    "    return actor\n",
    "\n",
    "def load_policy():\n",
    "    test = Policy(product_num = 9, win_size = 3, action_size = 3).cuda()\n",
    "    test.load_state_dict(torch.load(model_add+pg_model_name))\n",
    "    return test\n",
    "    \n",
    "def test_model(env, actor, policy):\n",
    "    eps = 1e-8\n",
    "    actions = []\n",
    "    weights = []\n",
    "    observation, info = env.reset()\n",
    "    observation = obs_normalizer(observation)\n",
    "    observation = observation.transpose(2, 0, 1)\n",
    "    done = False\n",
    "    ep_reward = 0\n",
    "    wealth=10000\n",
    "    wealths = [wealth]\n",
    "    while not done:\n",
    "        observation = torch.tensor(observation, dtype=torch.float).unsqueeze(0).cuda()\n",
    "        action = actor(observation).squeeze(0).cpu().detach().numpy()\n",
    "        # Here is the code for the policy gradient\n",
    "        actions_prob = policy(observation)\n",
    "        m = Categorical(actions_prob)\n",
    "        # Selection action by sampling the action prob\n",
    "        action_policy = m.sample()\n",
    "        actions.append(action_policy.cpu().numpy())\n",
    "        w1 = np.clip(action, 0, 1)  # np.array([cash_bias] + list(action))  # [w0, w1...]\n",
    "        w1 /= (w1.sum() + eps)\n",
    "        weights.append(w1)\n",
    "        observation, reward,policy_reward, done, info = env.step(action,action_policy)\n",
    "        r = info['log_return']\n",
    "        wealth=wealth*math.exp(r)\n",
    "        wealths.append(wealth)\n",
    "        ep_reward += reward\n",
    "        observation = obs_normalizer(observation)\n",
    "        observation = observation.transpose(2, 0, 1)\n",
    "    return actions, weights,wealths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape for observations -- T:  (2047, 8, 9, 1)\n",
      "Shape for Test observations -- T:  (410, 8, 9, 1)\n"
     ]
    }
   ],
   "source": [
    "# Testing enviroment\n",
    "data_add ='Data/'\n",
    "train_ratio = 0.8\n",
    "window_size = 1\n",
    "window_length = 3\n",
    "market_feature = ['Open','High','Low','Close','QPL1','QPL-1','QPL2','QPL-2']\n",
    "feature_num = 8\n",
    "product_num =9\n",
    "product_list = [\"AUDCAD\",\"AUDUSD\",\"EURAUD\",\"EURCAD\",\"EURUSD\",\"GBPUSD\",\"NZDCHF\",\"NZDUSD\",\"USDCHF\"]\n",
    "observations,ts_d_len = load_observations(window_size,market_feature,feature_num,product_list)\n",
    "train_size = int(train_ratio*ts_d_len)\n",
    "#print(train_size)\n",
    "test_observations = observations[int(train_ratio * observations.shape[0]):]\n",
    "test_observations = np.squeeze(test_observations)\n",
    "test_observations = test_observations.transpose(2, 0, 1)\n",
    "\n",
    "mode = \"Test\"\n",
    "steps = 405\n",
    "env = envs(product_list,market_feature,feature_num,steps,window_length,mode,start_index=train_size+282,start_date='2019-6-25')\n",
    "actor = load_actor()\n",
    "policy = load_policy()\n",
    "test_actions, test_weight,wealths1= test_model(env,actor,policy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "from environment.QF_env_1 import envs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'QFPIS_DDPG_1'\n",
    "pg_model_name = 'QFPIS_PG_1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_actor():\n",
    "    actor = Actor(product_num =9,win_size = 3).cuda()\n",
    "    actor.load_state_dict(torch.load(model_add+model_name))\n",
    "    return actor\n",
    "\n",
    "def load_policy():\n",
    "    test = Policy(product_num = 9, win_size = 3, action_size = 2).cuda()\n",
    "    test.load_state_dict(torch.load(model_add+pg_model_name))\n",
    "    return test\n",
    "    \n",
    "def test_model(env, actor, policy):\n",
    "    eps = 1e-8\n",
    "    actions = []\n",
    "    weights = []\n",
    "    observation, info = env.reset()\n",
    "    observation = obs_normalizer(observation)\n",
    "    observation = observation.transpose(2, 0, 1)\n",
    "    done = False\n",
    "    ep_reward = 0\n",
    "    wealth=10000\n",
    "    wealths = [wealth]\n",
    "    while not done:\n",
    "        observation = torch.tensor(observation, dtype=torch.float).unsqueeze(0).cuda()\n",
    "        action = actor(observation).squeeze(0).cpu().detach().numpy()\n",
    "        # Here is the code for the policy gradient\n",
    "        actions_prob = policy(observation)\n",
    "        m = Categorical(actions_prob)\n",
    "        # Selection action by sampling the action prob\n",
    "        action_policy = m.sample()\n",
    "        actions.append(action_policy.cpu().numpy())\n",
    "        w1 = np.clip(action, 0, 1)  # np.array([cash_bias] + list(action))  # [w0, w1...]\n",
    "        w1 /= (w1.sum() + eps)\n",
    "        weights.append(w1)\n",
    "        observation, reward,policy_reward, done, info = env.step(action,action_policy)\n",
    "        r = info['log_return']\n",
    "        wealth=wealth*math.exp(r)\n",
    "        wealths.append(wealth)\n",
    "        ep_reward += reward\n",
    "        observation = obs_normalizer(observation)\n",
    "        observation = observation.transpose(2, 0, 1)\n",
    "    return actions, weights,wealths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape for observations -- T:  (2047, 6, 9, 1)\n",
      "Shape for Test observations -- T:  (410, 6, 9, 1)\n"
     ]
    }
   ],
   "source": [
    "data_add ='Data/'\n",
    "train_ratio = 0.8\n",
    "window_size = 1\n",
    "window_length = 3\n",
    "market_feature = ['Open','High','Low','Close','QPL1','QPL-1']\n",
    "feature_num = 6\n",
    "product_list = [\"AUDCAD\",\"AUDUSD\",\"EURAUD\",\"EURCAD\",\"EURUSD\",\"GBPUSD\",\"NZDCHF\",\"NZDUSD\",\"USDCHF\"]\n",
    "observations,ts_d_len = load_observations(window_size,market_feature,feature_num,product_list)\n",
    "train_size = int(train_ratio*ts_d_len)\n",
    "\n",
    "test_observations = observations[int(train_ratio * observations.shape[0]):]\n",
    "test_observations = np.squeeze(test_observations)\n",
    "test_observations = test_observations.transpose(2, 0, 1)\n",
    "\n",
    "mode = \"Test\"\n",
    "steps = 405\n",
    "env = envs(product_list,market_feature,feature_num,steps,window_length,mode,start_index=train_size+282,start_date='2019-6-25')\n",
    "actor = load_actor()\n",
    "policy = load_policy()\n",
    "test_actions, test_weight,wealths2 = test_model(env,actor,policy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "from environment.QF_env import envs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "model_name = 'DDPG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "def load_model():\n",
    "    actor = Actor(product_num = 9,win_size = 3).cuda()\n",
    "    actor.load_state_dict(torch.load(model_add+model_name))\n",
    "    return actor\n",
    "    \n",
    "def test_model(env, model):\n",
    "    observation, info = env.reset()\n",
    "    observation = obs_normalizer(observation)\n",
    "    observation = observation.transpose(2, 0, 1)\n",
    "    done = False\n",
    "    ep_reward = 0\n",
    "    counter = 0\n",
    "    wealth=10000\n",
    "    wealths = [wealth]\n",
    "    while not done:\n",
    "        observation = torch.tensor(observation, dtype=torch.float).unsqueeze(0).cuda()\n",
    "        action = model(observation).squeeze(0).cpu().detach().numpy()\n",
    "        observation, reward, done, info = env.step(action)\n",
    "        ep_reward += reward\n",
    "        r = info['log_return']\n",
    "        wealth=wealth*math.exp(r)\n",
    "        wealths.append(wealth)\n",
    "        observation = obs_normalizer(observation)\n",
    "        observation = observation.transpose(2, 0, 1)\n",
    "    return wealths"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape for observations -- T:  (2047, 4, 9, 1)\n",
      "Shape for Test observations -- T:  (410, 4, 9, 1)\n"
     ]
    }
   ],
   "source": [
    "data_add ='Data/'\n",
    "train_ratio = 0.8\n",
    "window_size = 1\n",
    "window_length = 3\n",
    "market_feature = ['Open','High','Low','Close']\n",
    "feature_num = 4\n",
    "product_list = [\"AUDCAD\",\"AUDUSD\",\"EURAUD\",\"EURCAD\",\"EURUSD\",\"GBPUSD\",\"NZDCHF\",\"NZDUSD\",\"USDCHF\"]\n",
    "observations,ts_d_len = load_observations(window_size,market_feature,feature_num,product_list)\n",
    "train_size = int(train_ratio*ts_d_len)\n",
    "test_observations = observations[int(train_ratio * observations.shape[0]):]\n",
    "test_observations = np.squeeze(test_observations)\n",
    "test_observations = test_observations.transpose(2, 0, 1)\n",
    "mode = \"Test\"\n",
    "steps = 405\n",
    "env = envs(product_list,market_feature,feature_num,steps,window_length,mode,start_index=train_size+282,start_date='2019-6-25')\n",
    "model = load_model()\n",
    "wealths3 = test_model(env,model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "ts = pd.read_csv(\"Data/AUDUSD.csv\")\n",
    "ts = ts[::-1].copy()\n",
    "date  = ts['date'][0:407]\n",
    "date = pd.to_datetime(date) \n",
    "date = date[::-1].copy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x360 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure()\n",
    "plt.rcParams['figure.figsize'] = (8.0, 5.0)\n",
    "\n",
    "plt.plot(date,wealths2, label='QFPIS-1')\n",
    "plt.plot(date,wealths1, label='QFPIS-2')\n",
    "plt.plot(date,wealths3, label='DDPG')\n",
    "\n",
    "plt.grid(True)\n",
    "plt.xlabel(\"Date\",fontsize=15)\n",
    "plt.xticks(rotation=45)\n",
    "plt.legend(loc='upper left')\n",
    "plt.ylabel(\"Portfolio value\",fontsize=15)\n",
    "\n",
    "plt.savefig(\"figure/backtest/backtest.png\",dpi=600,bbox_inches = 'tight')"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}