Full Code of yuriak/RLQuant for AI

master 1ed3b813393e cached
62 files
16.8 MB
4.4M tokens
397 symbols
1 requests
Copy disabled (too large) Download .txt
Showing preview only (17,676K chars total). Download the full file to get everything.
Repository: yuriak/RLQuant
Branch: master
Commit: 1ed3b813393e
Files: 62
Total size: 16.8 MB

Directory structure:
gitextract_2mw6s78b/

├── EnvTestCRC_DRL.ipynb
├── EnvTestCRC_RPG.ipynb
├── EnvTestFuturesNews_DRL.ipynb
├── EnvTestFuturesNews_RPG.ipynb
├── EnvTestStock_DRL.ipynb
├── EnvTestStock_RPG.ipynb
├── README.md
├── agents/
│   ├── __init__.py
│   ├── agent.py
│   ├── drl_agent.py
│   ├── drl_news_agent.py
│   ├── rpg_agent.py
│   └── rpg_news_agent.py
├── crypto_currency/
│   ├── DDPG.ipynb
│   ├── DDRPG_shareV.ipynb
│   ├── DQN.ipynb
│   ├── DataUtils.py
│   ├── DirectRL.ipynb
│   ├── HuobiServices.py
│   ├── PolicyGradient.ipynb
│   ├── PortfolioSelection.ipynb
│   ├── RecurrentPG.ipynb
│   ├── RecurrentPG_shareV.ipynb
│   └── Utils.py
├── env/
│   ├── __init__.py
│   ├── crc_env.py
│   ├── futures_env.py
│   ├── stock_env.py
│   └── zipline_env.py
├── history/
│   ├── DRL_PairsTrading.py
│   ├── DRL_Portfolio.py
│   ├── DRL_Portfolio_Alpha.py
│   ├── DRL_Portfolio_Isolated.py
│   ├── DRL_Portfolio_Isolated_Simple.py
│   ├── PairsTradingBacktest.py
│   ├── PairsTradingTutorial.ipynb
│   ├── PortfolioBacktest.py
│   ├── PortfolioBacktestAlpha.py
│   ├── PortfolioBacktestIsoloated.py
│   ├── PortfolioBacktestNews.py
│   ├── PortfolioBacktestNewsAlpha.py
│   ├── PortfolioTutorial.ipynb
│   ├── Tutorial.ipynb
│   └── ZiplineTensorboard.py
├── model_archive/
│   ├── DRL_Portfolio_Highway.py
│   ├── DRL_Portfolio_Isolated.py
│   ├── DRL_Portfolio_Isolated_Hedge.py
│   ├── DRL_Portfolio_Isolated_Simple.py
│   ├── DRL_Portfolio_Simple.py
│   ├── DRL_Portfolio_Whatever.py
│   ├── HedgeFundTradingExample.py
│   ├── HyperParameterTuning.py
│   ├── ResultAnalysis.ipynb
│   ├── SimpleModel.py
│   ├── TradingExample.py
│   └── __init__.py
└── utils/
    ├── DataUtils.py
    ├── EnvironmentUtils.py
    ├── HuobiServices.py
    ├── SysUtils.py
    ├── ZiplineTensorboard.py
    └── __init__.py

================================================
FILE CONTENTS
================================================

================================================
FILE: EnvTestCRC_DRL.ipynb
================================================
{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pyfolio as pf\n",
    "import json\n",
    "%matplotlib inline\n",
    "from tqdm import tqdm_notebook\n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "%reload_ext autoreload\n",
    "%autoreload 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "config=json.loads(open('./config/huobi_config.json','r').read())\n",
    "ACCESS_KEY=config['ACCESS_KEY']\n",
    "SECRET_KEY=config['SECRET_KEY']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "from abc import abstractmethod\n",
    "\n",
    "\n",
    "class Agent(object):\n",
    "    def __init__(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def trade(self, state):\n",
    "        pass\n",
    "    \n",
    "    def train(self):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def load_model(self, model_path):\n",
    "        pass\n",
    "    \n",
    "    @abstractmethod\n",
    "    def save_model(self, model_path):\n",
    "        pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "import os\n",
    "import pandas as pd\n",
    "import talib\n",
    "import numpy as np\n",
    "from collections import OrderedDict\n",
    "from utils.HuobiServices import *\n",
    "\n",
    "lmap = lambda func, it: list(map(lambda x: func(x), it))\n",
    "lfilter = lambda func, it: list(filter(lambda x: func(x), it))\n",
    "\n",
    "\n",
    "class CryptoCurrencyEnv(object):\n",
    "    def __init__(self, instruments,\n",
    "                 access_key,\n",
    "                 secret_key,\n",
    "                 base_currency='btc',\n",
    "                 capital_base=1,\n",
    "                 data_local_path='./data',\n",
    "                 re_download=False,\n",
    "                 commission_fee=5e-3,\n",
    "                 normalize_length=10,\n",
    "                 data_interval='60min'\n",
    "                 ):\n",
    "\n",
    "        self.secret_key = secret_key\n",
    "        self.access_key = access_key\n",
    "        init_account(self.access_key, self.secret_key)\n",
    "\n",
    "        self.instruments = instruments\n",
    "        self.base_currency = base_currency\n",
    "        self.capital_base = capital_base\n",
    "        self.commission_fee = commission_fee\n",
    "        self.normalize_length = normalize_length\n",
    "        self.data_local_path = data_local_path\n",
    "        self.data_interval = data_interval\n",
    "\n",
    "        self.market_data = self._init_market_data(re_download=re_download)\n",
    "        self.pointer = normalize_length - 1\n",
    "        self.done = (self.pointer == (self.market_data.shape[1] - 1))\n",
    "\n",
    "        self.current_position = np.zeros(len(self.instruments))\n",
    "        self.current_portfolio_value = np.concatenate((np.zeros(len(self.instruments)), [self.capital_base]))\n",
    "        self.current_weight = np.concatenate((np.zeros(len(self.instruments)), [1.]))\n",
    "        self.current_date = self.market_data.major_axis[self.pointer]\n",
    "\n",
    "        self.portfolio_values = []\n",
    "        self.positions = []\n",
    "        self.weights = []\n",
    "        self.trade_dates = []\n",
    "\n",
    "    def reset(self):\n",
    "        self.pointer = self.normalize_length\n",
    "        self.current_position = np.zeros(len(self.instruments))\n",
    "        self.current_portfolio_value = np.concatenate((np.zeros(len(self.instruments)), [self.capital_base]))\n",
    "        self.current_weight = np.concatenate((np.zeros(len(self.instruments)), [1.]))\n",
    "        self.current_date = self.market_data.major_axis[self.pointer]\n",
    "        self.done = (self.pointer == (self.market_data.shape[1] - 1))\n",
    "\n",
    "        self.portfolio_values = []\n",
    "        self.positions = []\n",
    "        self.weights = []\n",
    "        self.trade_dates = []\n",
    "\n",
    "        return self._get_normalized_state(), self.done\n",
    "\n",
    "    def step(self, action):\n",
    "        assert action.shape[0] == len(self.instruments) + 1\n",
    "        assert np.sum(action) <= 1 + 1e5\n",
    "        current_price = self.market_data[:, :, 'close'].iloc[self.pointer].values\n",
    "        self._rebalance(action=action, current_price=current_price)\n",
    "\n",
    "        self.pointer += 1\n",
    "        self.done = (self.pointer == (self.market_data.shape[1] - 1))\n",
    "        next_price = self.market_data[:, :, 'close'].iloc[self.pointer].values\n",
    "        reward = self._get_reward(current_price=current_price, next_price=next_price)\n",
    "        state = self._get_normalized_state()\n",
    "        return state, reward, self.done\n",
    "\n",
    "    def _rebalance(self, action, current_price):\n",
    "        target_weight = action\n",
    "        target_value = np.sum(self.current_portfolio_value) * target_weight\n",
    "        target_position = target_value[:-1] / current_price\n",
    "        trade_amount = target_position - self.current_position\n",
    "        commission_cost = np.sum(self.commission_fee * np.abs(trade_amount) * current_price)\n",
    "\n",
    "        self.current_position = target_position\n",
    "        self.current_portfolio_value = target_value - commission_cost\n",
    "        self.current_weight = target_weight\n",
    "        self.current_date = self.market_data.major_axis[self.pointer]\n",
    "\n",
    "        self.positions.append(self.current_position.copy())\n",
    "        self.weights.append(self.current_weight.copy())\n",
    "        self.portfolio_values.append(self.current_portfolio_value.copy())\n",
    "        self.trade_dates.append(self.current_date)\n",
    "\n",
    "    def _get_normalized_state(self):\n",
    "        data = self.market_data.iloc[:, self.pointer + 1 - self.normalize_length:self.pointer + 1, :].values\n",
    "        state = ((data - np.mean(data, axis=1, keepdims=True)) / (np.std(data, axis=1, keepdims=True) + 1e-5))[:, -1, :]\n",
    "        return np.concatenate((state, self.current_weight[:-1][:, None]), axis=1)\n",
    "\n",
    "    def get_meta_state(self):\n",
    "        return self.market_data.iloc[:, self.pointer, :]\n",
    "\n",
    "    def _get_reward(self, current_price, next_price):\n",
    "        return_rate = (next_price / current_price)\n",
    "        log_return = np.log(return_rate)\n",
    "        last_weight = self.current_weight.copy()\n",
    "        securities_value = self.current_portfolio_value[:-1] * return_rate\n",
    "        self.current_portfolio_value[:-1] = securities_value\n",
    "        self.current_weight = self.current_portfolio_value / np.sum(self.current_portfolio_value)\n",
    "        reward = last_weight[:-1] * log_return\n",
    "        return reward\n",
    "\n",
    "    def _init_market_data(self, data_name='crc_market_data.pkl', re_download=False):\n",
    "        data_path = self.data_local_path + '/' + data_name\n",
    "        if not os.path.exists(self.data_local_path):\n",
    "            os.mkdir(self.data_local_path)\n",
    "        if not os.path.exists(data_path) or re_download:\n",
    "            print('Start to download crc market data')\n",
    "            market_data = CryptoCurrencyEnv.klines(instruments=self.instruments,\n",
    "                                                   base_currency=self.base_currency,\n",
    "                                                   interval=self.data_interval)\n",
    "            market_data = CryptoCurrencyEnv._pre_process(market_data, open_c='open', high_c='high', low_c='low', close_c='close', volume_c='vol')\n",
    "            market_data.to_pickle(data_path)\n",
    "            print('Done')\n",
    "        else:\n",
    "            print('market data exist, loading')\n",
    "            market_data = pd.read_pickle(data_path).fillna(method='ffill').fillna(method='bfill')\n",
    "        return market_data\n",
    "\n",
    "    def get_summary(self):\n",
    "        portfolio_value_df = pd.DataFrame(np.array(self.portfolio_values), index=np.array(self.trade_dates), columns=self.instruments + ['cash'])\n",
    "        positions_df = pd.DataFrame(np.array(self.positions), index=np.array(self.trade_dates), columns=self.instruments)\n",
    "        weights_df = pd.DataFrame(np.array(self.weights), index=np.array(self.trade_dates), columns=self.instruments + ['cash'])\n",
    "        return portfolio_value_df, positions_df, weights_df\n",
    "\n",
    "    @staticmethod\n",
    "    def _pre_process(market_data, open_c, high_c, low_c, close_c, volume_c):\n",
    "        market_data = lmap(lambda x: (x[0], CryptoCurrencyEnv._get_indicators(x[1], close_name=close_c, high_name=high_c, low_name=low_c, open_name=open_c, volume_name=volume_c)), market_data)\n",
    "        market_data = OrderedDict(market_data)\n",
    "        market_data = pd.Panel(market_data)\n",
    "        return market_data\n",
    "\n",
    "    @staticmethod\n",
    "    def kline(instrument, base_currency='btc', interval='60min', count=2000):\n",
    "        s = get_kline('{0}{1}'.format(instrument, base_currency), interval, count)\n",
    "        if s is None: return None\n",
    "        s = s['data']\n",
    "        s = pd.DataFrame(s)[::-1]\n",
    "        if s.shape[0] < count:\n",
    "            return None\n",
    "        s.index = pd.DatetimeIndex(s['id'].apply(lambda x: datetime.datetime.utcfromtimestamp(x) + datetime.timedelta(hours=8)))\n",
    "        s = s.drop('id', axis=1)\n",
    "        s['AVG'] = (np.mean(s[['open', 'high', 'low', 'close']], axis=1))\n",
    "        s['LOG_RR'] = np.log(s['close'] / s['close'].shift(1)).fillna(0)\n",
    "        s['RR'] = s['close'] / s['close'].shift(1)\n",
    "        return s\n",
    "\n",
    "    @staticmethod\n",
    "    def klines(instruments, base_currency='btc', interval='60min', count=2000):\n",
    "        return lfilter(lambda x: x[1] is not None, lmap(lambda x: (x, CryptoCurrencyEnv.kline(x, base_currency=base_currency, interval=interval, count=count)), instruments))\n",
    "\n",
    "    @staticmethod\n",
    "    def _get_indicators(stock, open_name, close_name, high_name, low_name, volume_name='vol'):\n",
    "        open_price = stock[open_name].values\n",
    "        close_price = stock[close_name].values\n",
    "        low_price = stock[low_name].values\n",
    "        high_price = stock[high_name].values\n",
    "        volume = stock[volume_name].values\n",
    "        data = stock.copy()\n",
    "        data['MOM'] = talib.MOM(close_price)\n",
    "        data['HT_DCPERIOD'] = talib.HT_DCPERIOD(close_price)\n",
    "        data['HT_DCPHASE'] = talib.HT_DCPHASE(close_price)\n",
    "        data['sine'], data['leadsine'] = talib.HT_SINE(close_price)\n",
    "        data['inphase'], data['quadrature'] = talib.HT_PHASOR(close_price)\n",
    "        data['ADXR'] = talib.ADXR(high_price, low_price, close_price)\n",
    "        data['APO'] = talib.APO(close_price)\n",
    "        data['AROON_UP'], _ = talib.AROON(high_price, low_price)\n",
    "        data['CCI'] = talib.CCI(high_price, low_price, close_price)\n",
    "        data['PLUS_DI'] = talib.PLUS_DI(high_price, low_price, close_price)\n",
    "        data['PPO'] = talib.PPO(close_price)\n",
    "        data['macd'], data['macd_sig'], data['macd_hist'] = talib.MACD(close_price)\n",
    "        data['CMO'] = talib.CMO(close_price)\n",
    "        data['ROCP'] = talib.ROCP(close_price)\n",
    "        data['fastk'], data['fastd'] = talib.STOCHF(high_price, low_price, close_price)\n",
    "        data['TRIX'] = talib.TRIX(close_price)\n",
    "        data['ULTOSC'] = talib.ULTOSC(high_price, low_price, close_price)\n",
    "        data['WILLR'] = talib.WILLR(high_price, low_price, close_price)\n",
    "        data['NATR'] = talib.NATR(high_price, low_price, close_price)\n",
    "        data['MFI'] = talib.MFI(high_price, low_price, close_price, volume)\n",
    "        data['RSI'] = talib.RSI(close_price)\n",
    "        data['AD'] = talib.AD(high_price, low_price, close_price, volume)\n",
    "        data['OBV'] = talib.OBV(close_price, volume)\n",
    "        data['EMA'] = talib.EMA(close_price)\n",
    "        data['SAREXT'] = talib.SAREXT(high_price, low_price)\n",
    "        data['TEMA'] = talib.EMA(close_price)\n",
    "        data = data.drop([open_name, high_name, low_name, 'amount', 'count'], axis=1)\n",
    "        data = data.dropna().astype(np.float32)\n",
    "        return data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "# -*- coding:utf-8 -*-\n",
    "from agents.agent import Agent\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import numpy as np\n",
    "import os\n",
    "\n",
    "\n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, s_dim, b_dim, rnn_layers=1, dp=0.2):\n",
    "        super(Actor, self).__init__()\n",
    "        self.s_dim = s_dim\n",
    "        self.b_dim = b_dim\n",
    "        self.rnn_layers = rnn_layers\n",
    "        self.gru = nn.GRU(self.s_dim, 128, self.rnn_layers, batch_first=True)\n",
    "        self.fc_policy_1 = nn.Linear(128, 128)\n",
    "        self.fc_policy_2 = nn.Linear(128, 64)\n",
    "        self.fc_policy_out = nn.Linear(64, 1)\n",
    "        self.fc_cash_out = nn.Linear(64, 1)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.tanh = nn.Tanh()\n",
    "        self.dropout = nn.Dropout(p=dp)\n",
    "        self.softmax = nn.Softmax()\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.initial_hidden = torch.zeros(self.rnn_layers, self.b_dim, 128, dtype=torch.float32)\n",
    "\n",
    "    def forward(self, state, hidden=None, train=False):\n",
    "        state, h = self.gru(state, hidden)\n",
    "        if train:\n",
    "            state = self.dropout(state)\n",
    "        state = self.relu(self.fc_policy_1(state))\n",
    "        state = self.relu(self.fc_policy_2(state))\n",
    "        cash = self.sigmoid(self.fc_cash_out(state))\n",
    "        action = self.sigmoid(self.fc_policy_out(state)).squeeze(-1).t()\n",
    "        cash = cash.mean(dim=0)\n",
    "        action = torch.cat(((1 - cash) * action, cash), dim=-1)\n",
    "        action = action / (action.sum(dim=-1, keepdim=True) + 1e-10)\n",
    "        return action, h.data\n",
    "\n",
    "\n",
    "class DRLAgent(Agent):\n",
    "    def __init__(self, s_dim, b_dim, batch_length=64, learning_rate=1e-3, rnn_layers=1):\n",
    "        super().__init__()\n",
    "        self.s_dim = s_dim\n",
    "        self.b_dim = b_dim\n",
    "        self.batch_length = batch_length\n",
    "        self.pointer = 0\n",
    "        self.s_buffer = []\n",
    "        self.d_buffer = []\n",
    "\n",
    "        self.train_hidden = None\n",
    "        self.trade_hidden = None\n",
    "        self.actor = Actor(s_dim=self.s_dim, b_dim=self.b_dim, rnn_layers=rnn_layers)\n",
    "        self.optimizer = optim.Adam(self.actor.parameters(), lr=learning_rate)\n",
    "\n",
    "    def _trade(self, state, train=False):\n",
    "        with torch.no_grad():\n",
    "            a, self.trade_hidden = self.actor(state[:, None, :], self.trade_hidden, train=False)\n",
    "        return a\n",
    "\n",
    "    def trade(self, state, train=False):\n",
    "        state_ = torch.tensor(state, dtype=torch.float32)\n",
    "        action = self._trade(state_, train=train)\n",
    "        return action.numpy().flatten()\n",
    "\n",
    "    def train(self):\n",
    "        self.optimizer.zero_grad()\n",
    "        s = torch.stack(self.s_buffer).t()\n",
    "        d = torch.stack(self.d_buffer)\n",
    "        a_hat, self.train_hidden = self.actor(s, self.train_hidden, train=True)\n",
    "        reward = -(a_hat[:, :-1] * d).mean()\n",
    "        reward.backward()\n",
    "        for param in self.actor.parameters():\n",
    "            param.grad.data.clamp_(-1, 1)\n",
    "        self.optimizer.step()\n",
    "\n",
    "    def reset_model(self):\n",
    "        self.s_buffer = []\n",
    "        self.d_buffer = []\n",
    "        self.trade_hidden = None\n",
    "        self.train_hidden = None\n",
    "        self.pointer = 0\n",
    "\n",
    "    def save_transition(self, state, diff):\n",
    "        if self.pointer < self.batch_length:\n",
    "            self.s_buffer.append(torch.tensor(state, dtype=torch.float32))\n",
    "            self.d_buffer.append(torch.tensor(diff, dtype=torch.float32))\n",
    "            self.pointer += 1\n",
    "        else:\n",
    "            self.s_buffer.pop(0)\n",
    "            self.d_buffer.pop(0)\n",
    "            self.s_buffer.append(torch.tensor(state, dtype=torch.float32))\n",
    "            self.d_buffer.append(torch.tensor(diff, dtype=torch.float32))\n",
    "\n",
    "    def load_model(self, model_path='./DRL_Torch'):\n",
    "        self.actor = torch.load(model_path + '/model.pkl')\n",
    "\n",
    "    def save_model(self, model_path='./DRL_Torch'):\n",
    "        if not os.path.exists(model_path):\n",
    "            os.mkdir(model_path)\n",
    "        torch.save(self.actor, model_path + '/model.pkl')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start to download crc market data\n",
      "Done\n"
     ]
    }
   ],
   "source": [
    "env=CryptoCurrencyEnv(instruments=['eth','bat','mds','soc','wicc'],\n",
    "                      access_key=ACCESS_KEY,\n",
    "                      secret_key=SECRET_KEY,\n",
    "                      re_download=True,commission_fee=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "b_dim=env.market_data.shape[0]\n",
    "s_dim=env.market_data.shape[-1]+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "agent=DRLAgent(b_dim=b_dim,s_dim=s_dim,batch_length=64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<p>Failed to display Jupyter Widget of type <code>HBox</code>.</p>\n",
       "<p>\n",
       "  If you're reading this message in Jupyter Notebook or JupyterLab, it may mean\n",
       "  that the widgets JavaScript is still loading. If this message persists, it\n",
       "  likely means that the widgets JavaScript library is either not installed or\n",
       "  not enabled. See the <a href=\"https://ipywidgets.readthedocs.io/en/stable/user_install.html\">Jupyter\n",
       "  Widgets Documentation</a> for setup instructions.\n",
       "</p>\n",
       "<p>\n",
       "  If you're reading this message in another notebook frontend (for example, a static\n",
       "  rendering on GitHub or <a href=\"https://nbviewer.jupyter.org/\">NBViewer</a>),\n",
       "  it may mean that your frontend doesn't currently support widgets.\n",
       "</p>\n"
      ],
      "text/plain": [
       "HBox(children=(IntProgress(value=0, max=10), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.55847025\n",
      "0.8364979\n",
      "1.5341458\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAEfCAYAAABLbN1EAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\ntfVJKn8j1wAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f28542dc128>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for e in tqdm_notebook(range(10)):\n",
    "    state,done=env.reset()\n",
    "    agent.reset_model()\n",
    "    while not done:\n",
    "        action=agent.trade(state,train=True)\n",
    "        next_state,reward,done=env.step(action=action)\n",
    "        next_log_rr=env.get_meta_state().loc['LOG_RR'].values\n",
    "        agent.save_transition(state=state,diff=next_log_rr)\n",
    "        state=next_state\n",
    "        if env.pointer % 64==0:\n",
    "            agent.train()\n",
    "    pv,pp,pw=env.get_summary()\n",
    "    print(pv.iloc[-1].sum())\n",
    "    total_pv=pv.sum(axis=1)\n",
    "    total_pv.name=str(e)\n",
    "    total_pv.plot(legend=True)\n",
    "    if pv.iloc[-1].sum()>1.5:break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "pv,pp,pw=env.get_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f284c7c0160>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAErCAYAAADUh5j/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f2854026f60>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "pv.sum(axis=1).plot()\n",
    "plt.title('strategy')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.axes._subplots.AxesSubplot at 0x7f2854f67a58>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAdwAAAJCCAYAAABqJ3ZbAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAhkQOtxAIBAIBDIgdLiBQCAQCGTA/wNkYRJHfBv5uQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f28540a4c88>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# pv.plot()\n",
    "plt.figure(figsize=(5,10))\n",
    "sns.heatmap(pv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "_,done=env.reset()\n",
    "weight=np.concatenate((np.ones(len(env.instruments))/len(env.instruments),[0]))\n",
    "while not done:\n",
    "    _,_,done=env.step(action=weight)\n",
    "    weight=env.current_weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "bpv,bpp,bpw=env.get_summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.text.Text at 0x7f284c795828>"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXgAAAErCAYAAADUh5j/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x7f28542085f8>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "bpv.sum(axis=1).plot()\n",
    "plt.title('buy and hold')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "pr=pv.sum(axis=1).pct_change()\n",
    "bpr=bpv.sum(axis=1).pct_change()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Entire data start date: 2018-05-26\n",
      "Entire data end date: 2018-08-13\n",
      "Backtest months: 90\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>Backtest</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>Annual return</th>\n",
       "      <td>5.8%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Cumulative returns</th>\n",
       "      <td>53.4%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Annual volatility</th>\n",
       "      <td>7.3%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sharpe ratio</th>\n",
       "      <td>0.82</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Calmar ratio</th>\n",
       "      <td>0.48</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Stability</th>\n",
       "      <td>0.91</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Max drawdown</th>\n",
       "      <td>-12.1%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Omega ratio</th>\n",
       "      <td>1.19</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Sortino ratio</th>\n",
       "      <td>1.27</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Skew</th>\n",
       "      <td>1.09</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Kurtosis</th>\n",
       "      <td>12.71</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Tail ratio</th>\n",
       "      <td>1.07</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Daily value at risk</th>\n",
       "      <td>-0.9%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Alpha</th>\n",
       "      <td>0.10</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>Beta</th>\n",
       "      <td>0.36</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "                    Backtest\n",
       "Annual return           5.8%\n",
       "Cumulative returns     53.4%\n",
       "Annual volatility       7.3%\n",
       "Sharpe ratio            0.82\n",
       "Calmar ratio            0.48\n",
       "Stability               0.91\n",
       "Max drawdown          -12.1%\n",
       "Omega ratio             1.19\n",
       "Sortino ratio           1.27\n",
       "Skew                    1.09\n",
       "Kurtosis               12.71\n",
       "Tail ratio              1.07\n",
       "Daily value at risk    -0.9%\n",
       "Alpha                   0.10\n",
       "Beta                    0.36"
      ]
     },
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA00AAAawCAYAAACwN7BMAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz\nAAALEgAACxIB0t1+/AAAIABJREFUeJzs3Xl8VNXdP/DPmSUzyWTPkIQkhEDYl0AwbIKsKooCWnCj\nZbFVrLX686mtre3T6vOr9un2aKu29eej1n1pKeJSVFRUEJB9hwAhQMi+78lklvP7Y5LL3MySyTaT\n5fN+vXx577nn3vudiS/Jl3PO9wgpJYiIiIiIiMgzTbADICIiIiIi6suYNBEREREREfnApImIiIiI\niMgHJk1EREREREQ+MGkiIiIiIiLygUkTERERERGRD0yaiIioTxFCPCaEeL0b958QQizowZCIiGiQ\nY9JEREQAACHEaiHEfiFEvRCiSAjxkRBibrDj8kUI8bIQ4nHXNinlRCnll0EKSSGE+FIIcVew4yAi\nou5j0kRERBBC/AjAnwD8BkACgFQAfwWwIphx9VVCCN1AeAcREfmHSRMR0SAnhIgC8H8B3Cel3CSl\nbJBSWqWUH0gpf9LaRzWiI4RYIITIdzm/IIT4iRDiqBCiQQjxohAioXW0qk4I8ZkQIsbTvS73X+0l\nvn8KIYqFEDVCiO1CiImt7RsAfBvAw62jYx+4PksIkSSEaBJCxLo8K1MIUS6E0Leef1cIcUoIUSWE\n+EQIMdxLDGlCCCmE+J4QIg/Attb2WUKIXUKIaiHEkbZpgUKIJwBcBeDZ1tiedXmGzuW5ymiUEGK9\nEGKnEOIpIUQFgMda274WQvyxNcbzQojrXe5fL4TIbf2Ozwshvu3zh01ERF3CpImIiGYDMAJ4t5vP\nWQngGgBjACwD8BGAnwMYAuefNw908bkfARgNIB7AQQBvAICU8vnW499LKcOllMtcb5JSFgLY3RpX\nm9UANkoprUKIFa3xfas1xh0A3uoglvkAxgNYIoRIBvBvAI8DiAXwYwD/EkIMkVL+ovV5P2yN7Yd+\nftaZAHLhHO17wqXtNAAzgN8DeFE4mQA8DeB6KWUEgCsBHPbzPURE1AlMmoiIKA5AuZTS1s3nPCOl\nLJFSFsCZMOyRUh6SUjbDmZBlduWhUsqXpJR1UkoLgMcATGkdHfPHmwDuAAAhhABwe2sbAHwfwH9L\nKU+1fvbfAJjqbbSp1WOtI3FNAL4DYIuUcouU0iGl/BTAfgBLO/sZXRRKKZ+RUtpa3wEAF6WU/yul\ntAN4BcBQOJMqAHAAmCSECJVSFkkpT3Tj3URE5AWTJiIiqgBg7oE1NCUux00ezsM7+0AhhFYI8Vsh\nxDkhRC2AC62XzH4+4l8AZgshhgKYB2eSsaP12nAAf26dWlcNoBKAAJDs43mXXI6HA7il7f7WZ8yF\nM6npqkse2orbDqSUja2H4VLKBgC3wZn8FQkh/i2EGNeNdxMRkRdMmoiIaDcAC4CbfPRpABDmcp7Y\njfepniWE0MI5Pc6T1XAWo7gaQBSAtLbbWv8tfb1ISlkFYCucycVqAG9LKdvuuQTgHilltMs/oVLK\nXb4e6XJ8CcBr7e43SSl/6yW2htZ/+/oefX4et2Ck/ERKeQ2ciVo2gP/tzP1EROQfJk1ERIOclLIG\nwK8A/EUIcZMQIkwIoRdCXC+E+H1rt8MAlgohYoUQiQAe7MYrzwAwCiFuaC3I8J8ADF76RsCZ0FXA\nmWz8pt31EgAjO3jfmwDWAliFy1PzAOA5AI+4FJaIEkLc0onP8TqAZUKIJa0jYsbWIhcpnmKTUpYB\nKADwndb+3wWQ3on3qbQW2ljRurbJAqAezpE0IiLqYUyaiIgIUsr/AfAjOBOYMjhHUX4IYHNrl9cA\nHIFzetxWAO904101AH4A4AU4k4gGAPleur8K4GJrv5MAvml3/UUAE1qnx21uf3Or9+EsJFEspTzi\nEse7AH4H4O3WqX/HAVzv+REeP8clOEfBfo7L39lPcPnP1j8DWNVa9e7p1ra7W/tUAJgIwNeoVkc0\ncP7MCuGcWjgfwL3deB4REXkhLs9SICIiIiIiovY40kREREREROQDkyYiIiIiIiIfmDQRERERERH5\nwKSJiIiIiIjIh+5uZNhnmc1mmZaWFuwwiIiIiIiojzpw4EC5lNLbXoGKAZs0paWlYf/+/cEOg4iI\niIiI+ighxEV/+nF6HhERERERkQ9MmoiIiIiIiHxg0kREREREROTDgF3T5IndbkdlZSWsVmuwQ+lX\n9Ho9YmNjodVqgx0KEREREVHADaqkqbKyEkajEWazGUKIYIfTL0gpUV9fj8rKSgwZ0mFhESIiIiKi\nAWdQTc+zWq0IDw9nwtQJQgiEh4dzdI6IiIiIBq1BlTQBYMLUBfzOiIiIiGgwG3RJExERERERUWcw\naQowIQQeeugh5fyPf/wjHnvsseAFREREREREPjFpCjCDwYBNmzahvLw82KEQEREREZEfmDQFmE6n\nw4YNG/DUU0+5Xbtw4QIWLVqEjIwMLF68GHl5eQCA9evX44EHHsCVV16JkSNHYuPGjco9f/jDHzB9\n+nRkZGTg0UcfDdjnICIiIiIaLAZVyXFXH3zwQa88d9myZR32ue+++5CRkYGHH35Y1X7//fdj3bp1\nWLduHV566SU88MAD2Lx5MwCgqKgIX3/9NbKzs7F8+XKsWrUKW7duxdmzZ7F3715IKbF8+XJs374d\n8+bN65XPRkREREQ0GHGkKQgiIyOxdu1aPP3006r23bt3Y/Xq1QCANWvW4Ouvv1au3XTTTdBoNJgw\nYQJKSkoAAFu3bsXWrVuRmZmJadOmITs7G2fPng3cByEiIiIiGgQG7UiTPyNCvenBBx/EtGnTcOed\nd/rV32AwKMdSSuXfjzzyCO65555eiZGIiIiIiDjSFDSxsbG49dZb8eKLLyptV155Jd5++20AwBtv\nvIGrrrrK5zOWLFmCl156CfX19QCAgoIClJaW9l7QRERERESDEJOmIHrooYdUVfSeeeYZ/P3vf0dG\nRgZee+01/PnPf/Z5/7XXXovVq1dj9uzZmDx5MlatWoW6urreDpuIiIiIaFARbVO9BpqsrCy5f/9+\nVVthYSGSkpKCFFH/xu+OiIiIiAYaIcQBKWVWR/040kREREREROQDkyYiIiIiIiIfmDQRERERERH5\nELCkSQjxkhCiVAhx3EefBUKIw0KIE0KIr1zarxNCnBZC5AghfhaYiImIiIiIiAI70vQygOu8XRRC\nRAP4K4DlUsqJAG5pbdcC+AuA6wFMAHCHEGJCr0dLRERERESEACZNUsrtACp9dFkNYJOUMq+1f9uG\nQzMA5Egpc6WULQDeBrCiV4MlIiIiIiJq1ZfWNI0BECOE+FIIcUAIsba1PRnAJZd++a1tboQQG4QQ\n+4UQ+8vKyno53K7RarWYOnUqpkyZgmnTpmHXrl1des769euxceNGt/Y//elPaGxs7NIzN2/ejJMn\nT3bpXiIiIiKi7nBIB94/9T5eP/Q6apprgh2OSl9KmnQArgBwA4AlAH4phBjTmQdIKZ+XUmZJKbOG\nDBnSGzF2W2hoKA4fPowjR47gv//7v/HII4/06POZNBERERFRf3S8+Dj2XNqDU2Wn8FnOZ8EOR6Uv\nJU35AD6RUjZIKcsBbAcwBUABgGEu/VJa2/q92tpaxMTEAADq6+uxePFiTJs2DZMnT8Z7772n9Hv1\n1VeRkZGBKVOmYM2aNW7P+eUvf4n169fjz3/+MwoLC7Fw4UIsXLgQALB161bMnj0b06ZNwy233IL6\n+noAwM9+9jNMmDABGRkZ+PGPf4xdu3bh/fffx09+8hNMnToV586dC8A3QEREREQESCnxzrF3lPOD\nhQeRXZYNh3QEMarLdMEOwMV7AJ4VQugAhACYCeApANkARgshRsCZLN0O5/qnbvnF1l909xFePXHt\nE16vNTU1YerUqWhubkZRURG2bdsGADAajXj33XcRGRmJ8vJyzJo1C8uXL8fJkyfx+OOPY9euXTCb\nzaisVC8L+8lPfoK6ujr8/e9/hxACTz31FL744guYzWaUl5fj8ccfx2effQaTyYTf/e53ePLJJ3Hf\nfffh3XffRXZ2NoQQqK6uRnR0NJYvX44bb7wRq1at6rXvhoiIiIiovUs1l9zaXjv0Gq4edTUWjFiA\nXXm7cLH6IhanL0ZCeELA4wtY0iSEeAvAAgBmIUQ+gEcB6AFASvmclPKUEOJjAEcBOAC8IKU83nrv\nDwF8AkAL4CUp5YlAxd3T2qbnAcDu3buxdu1aHD9+HFJK/PznP8f27duh0WhQUFCAkpISbNu2Dbfc\ncgvMZjMAIDY2VnnWr3/9a8ycORPPP/+8x3d98803OHnyJObMmQMAaGlpwezZsxEVFQWj0Yjvfe97\nuPHGG3HjjTf28qcmIiIiInJntVvRbGvG/9v7/zxe35e/D1qhxSdnPwEANLQ04O7pdwcyRAABTJqk\nlHf40ecPAP7goX0LgC29EVcwzZ49G+Xl5SgrK8OWLVtQVlaGAwcOQK/XIy0tDc3NzT7vnz59Og4c\nOIDKykpVMtVGSolrrrkGb731ltu1vXv34vPPP8fGjRvx7LPPKiNeRERERES9paqpCjsu7EBcWBzS\nY9Px4v4X0Wj1vh6/prlGSZgA4ELVBVhsFhh0hkCEq+hL0/MCytcUukDJzs6G3W5HXFwcampqEB8f\nD71ejy+++AIXL14EACxatAg333wzfvSjHyEuLk6VIF133XVYsmQJbrjhBmzduhURERGIiIhAXV0d\nzGYzZs2ahfvuuw85OTkYNWoUGhoaUFBQgKSkJDQ2NmLp0qWYM2cORo4cCQDKvURERERE3WW1W1HW\nUIYoYxQ+P/c5bA4biuuKUVDbvfIEZQ1lSIlK6aEo/TNok6ZgaVvTBDhHgl555RVotVp8+9vfxrJl\nyzB58mRkZWVh3LhxAICJEyfiF7/4BebPnw+tVovMzEy8/PLLyvNuueUW1NXVYfny5diyZQs2bNiA\n6667DklJSfjiiy/w8ssv44477oDFYgEAPP7444iIiMCKFSvQ3NwMKSWefPJJAMDtt9+Ou+++G08/\n/TQ2btyI9PT0wH45RERERDQgSCnxtz1/Q0l9SY8/u9nmezZWbxBSyoC/NBCysrLk/v37VW2FhYVI\nSkoKUkT9G787IiIiIvJXeUM5ntr5lF999Ro9fjr/pwjVh/pVrO2OKXdgUsKk7oYIABBCHJBSZnXU\nry+VHCciIiIiogHAYrP43ffeWfciVB8KABgWNayD3sEZaWLSREREREREParF3uJXv6TIJFUJ8RUT\nVsAUYvJ5T2cSsp4y6NY0SSkhhAh2GP3KQJ3CSURERES9w2L3L7FZPm656nxoxFA8PO9haIQGbxx+\nA9ll2e7PDkLSNKhGmvR6Perr65kEdIKUEvX19dDr9cEOhYiIiIj6uDpLHaqaqtwSmwfnPOixf4Qh\nwq1Np9FBIzRIivS8nj4Y0/MG1UhTbGwsKisrWVa7k/R6vcd9oIiIiIiI2pQ3lOPZ3c/CJm0YEzdG\nac9KzsIQ0xC3/nFhcYg0Rnp9XlxYnMf2JmtT94PtpEGVNGm1WgwZ4v4DIyIiIiKi7jlSfARWhxUA\ncLr8tNLubSPa9dPWQyO8T3yLDfX8l/Y1zTXdiLJrBtX0PCIiIiIi6h1FtUUe29uSptHm0UrbvLR5\niA3zPZPJ20hTZVNlFyPsOiZNRERERETULU3WJpwqO+XxWpg+DABww9gbkBiRiFFxo7AwfWGHz2y7\nr72a5ho4pKPrwXbBoJqeR0REREREPc91Ol57UxKnAACGmIbg/tn3+/1MIQQmJkzEiZITCNOHwWKz\nwC7tcEgHLDaLsrdTIDBpIiIiIiKibimtL/XYHqINQViI5xEjf9w0/iaMih2FtJg0vHroVVQ1VQFw\njmwxaSIiIiIion6jorHCY3uINqRbzw0LCcOMYTMAqAtKBLrsONc0ERERERFRt3grA+6tcl5XGHVG\n5ZhJExERERER9StNtt5PmkJ1l6fjBXqvJk7PIyIiIiKibvGWxOhEz6UbnR1parG3IKciBxqhQXps\nOvRafZffzaSJiIiIiIi6xVsSU95Y3mPvMOr9T5rKG8rx1M6nlPMoYxTumXEPooxRXXo3p+cRERER\nEVGXXaq+pBppSo1KVY7HDhnbY+9xrZbXUdK0N3+v6rymuQafnv20y+9m0kRERERERF1S3lCO5/Y+\np5wbdAasnroa5jAzDDoDrki6osfepZqeZ/WdNJ2vOu/WdrT4KKx2KwB0enNcTs8jIiIiIqIO2R12\naDVa5bzJ2oRnv3lW1ScjMQMRhgj8x9z/gEM6oBE9N0bTmZLjbfs5td3XtjHu77b/DovTF+OTM59g\nXPw4v9/NpImIiIiIiHzanbcbn5z5BJMSJmHV5FUorC3EX775i1u/FeNXKMc9mTAB6up5bUlTi70F\n3+R9gyZrEySkcq1tuqAQAmPNY3G0+CgAZ6L3YfaHAIBjxcf8fjeTJiIiIiIi8upU6Skl0ThUdAjx\n4fH45Ownbv0mxE+AEKLX4nCdnteWFO24sAPbzm3zeo+UEsmRyUrS1FVMmoiIiIiISMVqtyK/Jh8R\nhgi8ceQN1TVPCVO0MRoLRy7s1Zg8FYIoqSvp8L6hEUO7/W4mTUREREREpLA5bHhh/wvIr8n3q/+a\nzDUYN8T/9UFdFaYPU45rmmtQZ6nDxeqLStuouFEYGTsSX+R+oRR8SI1KxYjYEd1+N6vnERERERGR\n4nTZab8TJgABSZgAINIYCa1wFqJotDbit1/9FvUt9cr1JaOXYP6I+Xh00aPIHJqJhPAEXDf2OmiE\nBndMuaNb7+ZIExERERERKWosNX73nRg/sRcjUdMIDWJCY7xumNs2fU8IgVWTV6muJYYndu/d3bqb\niIiIiIgGFLvD7nffZeOX9WIk7mLDYr1ec52+19F9t2XchgUjF/j9Xo40ERERERGRwuaw+dUvLSYN\nEYaIXo5GzRRi8tiu1+gRog3xep9GaHDdmOvw+bnPMS1pGjISMzr1XiZNRERERESk8DTSlByZjILa\nAlWbQWtw69fbpJQe22enzu6w3PlVaVdhzvA5Xdo/ikkTEREREREpXJOm+SPmY+awmThTfgYFJ9sl\nTbrAJ00zh83E4aLDAIDR5tFYl7kONocNeq3er/u7uuEukyYiIiIiIlK4Ts8zhZgQZYzymCAFI2lK\njU7FivErUNFYgXkj5kEI4XfC1B1MmoiIiIiISGGXl0ea2kp8h+pC3frFhnovytCbZgybEfB3snoe\nEREREREpXEeadBrnGItRZ3TrNyxqWMBiCjYmTUREREREpHBd06TVtI406dUjTWH6MAyPGR7QuIKJ\nSRMRERERESmsDqty3JY0tV+/NClhUpeLKvRHg+eTEhERERFRh1xHmtqm57XfH6n9yNNAx6SJiIiI\niIgUngpBaIQGV6VdpbRPjJ8Y8LiCidXziIiIiIhIYbO7F4IAgKtHXY2Y0BhEG6ORHJUcjNCChkkT\nEREREREpVNPztJfTBZ1Gh5nDZgYjpKDj9DwiIiIiIgIA5FXnIa8mTzlvm5432DFpIiIiIiIiAMDe\nS3tV54Ot4IM3TJqIiIiIiAgAUNdSpxzHm+IRFxYXxGj6DiZNREREREQEAGi0NirHKyetDGIkfQuT\nJiIiIiIigs1hQ2FtoXJu1BmDGE3fwqSJiIiIiIhwpOiI6rz9hraDGZMmIiIiIqJBzmKz4KMzH6na\nONJ0GfdpIiIiIiIahKSUOFd5DqfKTuGbvG/crgshghBV38SkiYiIiIhoEDpUdAj/Ov4vj9fWZq4N\ncDR9G6fnERERERENQpeqL3lsjzREYmTsyABH07dxpImIiIiIaBCyS7vqfE3mGjS0NGB49HDotfog\nRdU3MWkiIiIiIhqEHA6Hcrxy0kqMGzIuiNH0bZyeR0REREQ0CLmONGmFNoiR9H1MmoiIiIiIBiG7\n43LSpBFMC3zht0NERERENAi5jjTpNFy14wuTJiIiIiKiQcg1aeJIk2/8doiIiIiIBiHXQhBaDdc0\n+cKkiYiIiIhoEGIhCP8xaSIiIiIiGoRcR5o0GqYFvvDbISIiIiIahGzSphxzpMk3Jk1ERERERIMQ\n1zT5j0kTEREREdEgxDVN/mPSREREREQ0CNkcl6fnseS4b/x2iIiIiIgGIYfk9Dx/MWkiIiIiIhqE\n7A5Oz/MXkyYiIiIiokHIdaSJJcd947dDRERERDQIuRaC0AldECPp+5g0ERERERENQtzc1n/8doiI\niIiIBhkpJTe37QQmTUREREREg4zFZoGUEgCg1+pZPa8DTJqIiIiIiAaZ+pZ65Tg8JDyIkfQPXPFF\nRERERDTA2Rw25FbmQkDAYrfgQMEB5ZopxBTEyPoHJk1ERERERAPcW0feQnZZtsdrDS0NAY6m/+H0\nPCIiIiKiAczusONM+Rmv19Oi0wIXTD/FpImIiIiIaACraqpSbWQ7fsh4pMWkAQB0Gh2mJk0NUmT9\nB6fnERERERENYGUNZcrxqLhR+E7mdwA4K+hZHVYWgvADkyYiIiIiogHMNWkym8zKsUFngAGGYITU\n73B6HhERERENKlJK2By2jjsOEKqkKczsoyd5w5EmIiIiIho0HNKB/937v7hUewkrxq/A9JTpwQ6p\nV9U01+Bg4UHlfIhpSBCj6b+YNBERERFRrytvKMenOZ8iNToVV6ZeCSFEUOLIr8lHXk0eAGDzyc1I\ni0kbcInE2fKz2JqzFWH6MOg06l/3h0UNC1JU/Run5xERERFRr2psacRLB17C8ZLj2HJ6C/7z0/+E\nxWYJSiz1LfWq8z2X9gQljt708dmPUVhbiJyKHNXeTKH6UBh0XMPUFUyaiIiIiKjXfJP3DZ748gnU\nNNeo2ndd3BXwWOwOO/5x9B+qttrm2oDH0duK64o9tt8/+/4ARzJwBCxpEkK8JIQoFUIc76DfdCGE\nTQixyqVtnRDibOs/63o/WiIiIiLqCR9kf+Cx/bNzn3X5mQ7pgN1hR1VTFU6XnYbdYffrvm8ufQOr\nw6pqa7A2dDmOvshqt3psN+lNiDJGBTiagSOQa5peBvAsgFe9dRBCaAH8DsBWl7ZYAI8CyAIgARwQ\nQrwvpazq1WiJiIiIqFv2Xtrr9VqINqTD+2uaaxBhiIBGXP57/mZrM57f9zxK6kuUtjB9GJaNW4YI\nYwSklNBqtEiJTIFWo1U972DBQbTX2NLoz0fps1rsLcitzMWlmktIjUpFfHi8x36mEFOAIxtYApY0\nSSm3CyHSOuh2P4B/AXAtY7IEwKdSykoAEEJ8CuA6AG/1QphERERE1EPeO/We6vyqtKuw48IOAIDN\nYYOU0mtBiC2nt2DnxZ0I1YeiydqEhPAEXDn8Smw9uxUNLerRoUZrI9459o7bMx648gEMMQ2BRmgg\npUR1c7Vbn0Zr/02a9uXvw0dnPlKtD4sNi/XY1yEdgQprQOoz1fOEEMkAbgawEOqkKRnAJZfz/NY2\nT8/YAGADAKSmpvZOoERERETUocNFh1XnJr0J1425Dt/kOafIOaQDLfYWj4UJ9hfsx86LOwEATdYm\nAEBJfQnePfFup2J4etfTAIB5afOQEJGAZluzW59Ga6PP5K2vstgs+DD7Q7f9piobKz329/TZyX99\nJmkC8CcAP5VSOrr6H62U8nkAzwNAVlaW7MHYiIiIiKgT/nnsn6rzlZNWAgCMeiOsFue6m2Zbs1vS\nVN5Q3unkqCPbL2xXnYdoQ9BibwHgHIEpbyzvd2XHi+uLO7VB7+zU2b0YzcDXl5KmLABvtyZMZgBL\nhRA2AAUAFrj0SwHwZaCDIyIiIiKnqqYqHCs+hrFDxiIhPAEAIKXEmfIzCNOHYWjkULd7xpjHAIBq\n36BTpadgsVtgc9gwd/hcFNcX4/m9z3f4/rYpe21iQmNw/+z7YdAZ8Nqh11Rltj1Jj01Hk60JF6ou\nAAD+tPNP+NWiX3W7HHdvj1hJKXGh+gJiQ2NRWFuotE8ZOgVzUufgb3v/Bimd4waZQzOxavIqHCg4\ngPqWeswaNqvX4hoM+kzSJKUc0XYshHgZwIdSys2thSB+I4SIab18LYBHghAiERER0aB3uuw0Xj3k\nrOv1ydlP8MPZP8TQiKHYX7Afm09uhhACN4y9we2+tmSixdaitLlW1ttxfodbZbuZw2ZirHksTpef\nxljzWIwxj4EQAg7pwJNfP4mqpipEGiLx0NyHlOf7Mw1Nr9Uj3BCuJE0AcKzkGLKSs/z/Ilw4pAOv\nH3odl2ouYeWklRg3ZFyXnuOqorECG49vRH5NPoaYhmDhyIUobSjFtnPbYNAZkGBKUPomRyYjOSoZ\nKyeuxBe5X2BC/AQsGb0EAHBF8hXdjoUCmDQJId6Cc8TILITIh7Minh4ApJTPebtPSlkphPg1gH2t\nTf+3rSgEEREREQXWm0feVJ0/u/tZzEubh30Fzl/VpJT4MPtDr/enRqfiVNkpt/b2CRMAzBk+B3Fh\ncRg7ZKyqXSM0+M7U7+Bk6UlkJGaoRndmDpupJEPXjLoGUcYobDy+0e3+lMgU7FN+vQQqGiq8xtyR\nnIocnC4/DQB47dBrWJy+GClRKcroWmc5pAPP731e2Yi3pL4Ebx99W7lusVmQV5OnnCdFJgEAMpMy\nkZmU2dWPQT4EsnreHZ3ou77d+UsAXurpmIiIiGhgqm2uRZOtSZk6Rj2jydrkcR1N+zVD7ek1euV4\nxYQVOPWVe9LU3oYZGxAXFuf1emJEIhIjEt3aJyVMQtXoKljtVsxNmwudRodQfSheO/Saqt+E+Al4\n9+TltVMVjV1PmlzLnwPA5+c+B+Ac5bl5ws2dnrJX01yjJEwdCdGGICkiqVPPp84L2Oa2RERERIFQ\n3lCOP+74I57e9TSOFh0NdjgDgpQS7596H49/8XiX7r99yu3KcYQhAg9c+QBMehNMISZlGpmru7Lu\nwvDo4V16l0ZoMH/EfFw96mpl/VT76XLpcekICwnDivErlLY6S12X3gc4k3RPDhQcwJHiI51+Xmf2\njpqWPK3ba7GoY0yaiIiIaEDZlrsNdmkHAI9791DnFdUVYc+lPV26NyMxA2PN6ul1CeEJeGTBI3h4\n3sOYN2Ko0OW7AAAgAElEQVQe/s+V/0d1fUh4z1ey+8HMHyAxIhGTEydj6tCpAJzJU5saS02Xn13e\nWO712hfnvuj08xqsl/eh8jSa1sakN2Hu8Lmdfj51Xp8pBEFERETUXQ7pwJGizv/NPvlW2aReTh5l\njMJdWXfhr3v+qqpipxEarJu2Dn8/8HelbXrKdI/T04QQ0Annr6Lx4fFYlL4IX+V+henDpiM8JLzH\nP0NyVDLun32/qi3SEKkc11nqOqx+J6XEhaoLyK3KxYGCA6hp7jjRcv1+/OW64W5cWByK64pV15eP\nX4702HSE6cMQFhLW6edT5zFpIiIiogGjoKbArc1qt0Kv1XvoTf5qP3Xt+zO+j0ijs2rdvvx9+Czn\nM0hI3DzxZqTHpiM5MhkFtQUYbR6NETEjvDxVbXH6YswfMV9Vkry36bV6hOnD0GhthEM6cKrsFCbE\nT/DY12Kz4Jndz6CqqapT7/BU4KIjDS2XR5o8JZBpMWkwm8ydfi51HZMmIiIiGjCabO5/q1/fUo+Y\n0BgPvclfrtXwFqcvRqTROUITqg/FvBHzMHPYTDikA6H6UADAPTPuQVVTFeLC4jpVBCGQCVMbvVYP\ntOY1bxx+A09c+4THfl9f/LrTCRMAtNhbOp24uyZNphCT2/V4U3yn46Du4ZomIiIiGjA87dHTnQX+\n/Ul5QzleO/QaPj7zsbLBaU9oX5QgwhDh1segMygJEwBoNVqYTeZe3ei1p7Rfb+WpOmCdpQ7bz6sr\nBHYmEXedbucP18ISUYYoVSGLNZlr+sX3OtBwpImIiIgGDIvN4tY2WJKm9069h9zKXGSXZWNoxFBM\nGTqlR55b3VytOu/q3kN91azUWdibv1c5/8P2P2DskLFICE+AQzrQZG3CV+e/Uq4nRiTivln3QSM0\nOF5yHG8deUu5tmHGBnyT9w3CQ8JxtuIsyhrKADhHjqKMUR3GYnPYUFJXgsPFh5W2SGMkrh9zPcL0\nYUiLSeuRjXOp85g0ERER0YBgc9g8jjS9eeRNPLb4sQG/rim3Mlc5PlJ0xGvSdLzkOHZe3In02HRc\nPepqj30c0gEBASEEai2XRz0SwhP8+uW/P0kIT0BaTJqyIW59Sz0OFBzw2n/J6CXQCOdkrbHmscq9\nqdGpSI1KxfAMZ6n0F/a9oCRNJfUlyga03tS31OMvu/+i+r4BZ9ENs8mMlZNWdvUjUg9g0kRERET9\nmt1hx4nSE9h0fJPXRfdvHHkDkYZIWO1WLB+/XDWVbCDyVrGtsrFSGRnJq87D1KFT3QoKFNYW4uWD\nL8OgM2DD9A24WH1RuZYSldJ7QQdRtDHar37TU6ZjdNxo5Vyv1eOurLtQ3VyNKGOUatpcanQqzled\nBwBsPL4RY8xjPK5PanOs+JhbwhSmD0NsaGxnPgr1EiZNRERE1G81W5vx7DfPdrhA/2z5WeU4JjQG\n146+trdDCypva2j+tPNPqvPKpkq3pGnHhR1oaGlAQ0sDXj/8OvJr8pVrntYzDQRhenXZ7hBtCLKS\nsyCEgEZooBEapMWkeZyaKITwuL5pQvwE1bS+v+35Gx6c86BS7MLusCOvOg9CCKREpai+Z8D53+mN\n424c8COk/QWTJiIiIuq39ubv7XRFs3OV53opmr7D02arFptF2fS3jWuVtjYnSk4ox+1/kW+fXAwU\n7T/Xmsw1GBk7slvPjAuLU51XNVXh0c8exa2Tb0V4SDjeOfqOahNbV+unrcdo82iP1yg4mDQRERFR\nv1VcX9xxp3ZK6kpgd9ih1Wh7IaK+o7S+FPHh8aiz1OG3X/3WY5/6lnq3tuTIZOTV5Hns72t6WX/W\nfrqmv9P1Onpm2x5Qrv5x7B8d3pcandrt91PPYslxIiIi6rc8TUNbk7kGjyx4xOs9VocVJfUlvRlW\nr2qyNsHusLu1J0cmq85PlZ0CABwqPOT1WfUWddK0P3+/14QJGLgjTe0LiPTUvl6zU2d3qn+YPgw3\nTbgJBp2hR95PPYcjTURERNQv1TbXqtYqAcCK8SuUksx3TLkDZ8vPYn/Bfrd7i+qKOqxm1hedKDmB\nd46+A7u0wxRiwvgh45GRmIERsSPc+rZNW/Q0Va+N60hTbmUu3j35rs/3D9T1NWPMY/BpzqcAgPTY\n9B7bB2lR+iJkJGbgn8f/6TbVEXBWxvvR3B+hsLYQEYYIbsLchzFpIiIiooBqtjYjryYPKZEpCAu5\nPHKRW5mL81XnlY1ZHdIBvVaPpIgklDeWIyMxQylEUNtci99t/53quSvGr8D0lOnK+aSESZiUMAla\njRZ7Lu1R9d10YhOmDJ2iLMrvL/Zc2qOsS2poacD+gv3YX7Afo82j3dYr+bOhqmvSdLjosI+eTj0x\nba0vSopMwtKxS1FUV4Sr0z2XYe8qs8mM78/4PhzSAQmJ1w69hpyKHADADWNvgE6j43S8fqB//Z+C\niIiI+iSHdOD9U++jqqkKN024yevfmEsp8fy+51FSX4IoYxQ2TN+A6NBoXKq+hJcOvKQkTJ7kVORg\n3bR12Je/D5tPblZdC9GGYMawGR7vW5y+GAatAdll2ShtKFXaDxQcwMxhM7vwaQNHSolDRYdQZ6nD\nrGGzUFBb4LHf2fKzbpXt2sqOe9q7qo1r0lTTXOO1X3hIOGalzhrQIyFzhs/ptWcLIaAVzjV066et\nR2VTJWJDY3tsRIt6H5MmIiIi6pKa5hp8cOoDVDRWqJKRD059gLXT1nq8p7q5WllPVNNcg/dOvYe1\nmWuxM2+nz4QJAM5WnMU7R9/B0eKjbtd8/fJpCjFhyZgliDPF4d0Tl6efnas41+eTpgtVF/Cv4/8C\nAGw9u9Vn3zpLneq8ttm554/FZlHaooxRGBU3Stm8tbiuGL/Y+gskRyZ7TMgMOgOykrOwdOzSbn0O\nukwI4VZZj/o+Jk1ERETUJe+dfA+ny0+7tZ8uP43KxkrEhrlvylndVK06P1N+Bp/mfIpjxceUtgnx\nEzA0Yig+P/e5qq+U0mPC1HZPRwTUiVWNxfvISrA5pANf5n6p2uens8oby3G+8jxabC1K220ZtyE5\nMllJmtp4G8H65cJfcjSECKyeR0RERF0gpfSYMLU5WXrSY3tVs/ueSu0Tg9VTVmNR+iJsmLHBr1ii\njFG4dlTHm9WOHTJWdV7eUN7h6FawHCs+hs/PfQ6bw+bx+tzhc/16zgv7X1BVwzNoDdBpdH5XZ2PC\nROTEkSYiIiLqFE9FGNqraKxwa6uz1ClTzbwZP2S88ov68Ojh+NWiX2F/wX5sOb3Fre+dV9yJtJg0\naIQGGtHx3wOHh4Tj3pn34m97/gbAudanxd7iNYGos9ShzlKHhPCEgOzpVFhbiNNlp1HZVImDhQd9\n9s1MyoTZZHZb29WRts/qOmWPiDrGpImIiIg6ZcsZ9wSmvcqmSgCA1W6FEAI6jc5tup0nrtXvAOcv\n+XOGz3FLmiYnTsaouFGdiNopJSoFphATGloaAMBr0vTeyfewN38vAGBa0jSsnLSy0+/qjFOlp/D6\n4df96htljILZZEZiRCImJUzCh9kf+lX5DvC+z9IPZv4ANmnD64deV6rutf9ZEA1mnJ5HREREneK6\n/qiNSW/CjeNuVM5zKnLwzO5n8F/b/gu//eq3OFp8FPvy913uH2LCmsw17s8JMXl854NzHlSOEyMS\ncdvk27ocv2uS1H6NlZQSX1/4WkmYAOBg4UGfleV6wp78PR32uXHcjVg5aSXunn63Uio9VB/qd0IX\nHhLuMUEM04chOSoZw6OH45EFj2D+iPmYnjId14y6pnMfgmgA40gTERERdWhf/j78+/S/4XA43K5N\nS5qGpWOXwqAzYPv57ai1OKu2FdcVA3CWvn7n6Duqex6a+xAMOgOuGXWNsqko4D1pGmIagvtm3YfT\n5acxdejUbq21MWgvJw7P7X0OOo0OWo3W55S13Xm7cd2Y67r8zo6cqzjXYZ8oY5THghcaoUFsWCwq\nGyt93j8rdZZyPDlxspL8ZqVkqZ517eiO14cRDTYcaSIiIiKfPj7zMTaf3Ayr3eq2gWpyZDK+NfFb\nCNWHQiM0fu11o9fqlREP1wp7QgiEh4R7vS8pMgkLRy7s9l5B7UdbbA5bh2t8dlzY0WvrgBpbGuGQ\n7sloe+2r/7kK16u/t5sn3OzWx6S/nJAuGb0EqdGpGGMegwUjFvgfLNEgxaSJiIiIvDpechw7Luzw\neG1iwkTcM+Me1ajPxISJHT7TtWjDuCHjMDFhIhLCE7By4krotfruB92BEG2IX/3aJ2eFdYW9EQ7K\nGsuUY6POiNsy3KcehoeE+1zD1X6EbmLCREQZo1Rtrj+nmNAY3DPjHqybts7vSnpEgxmn5xEREZFX\n+wv2e2yPC4vDjWNvdKsqF2GI6NTzQ7QhWD1ldZfj64r265N+Nv9nKGsoQ25lLnbl7YKUEmunrcXp\nstOqhLGxpVE5llJ2a4pgVVMVKhorcLH6Irad26a0jzaPRkZiBsbEjcGpslMYFjUMzbZmmMPMPhPK\n9kmTUWfEw/MexpNfP6lUMkyOTO5yvESDHZMmIiIi8uhEyQmcLT+rnN89/W4Mjx6unHtKGtoKFPRl\nofpQ5Viv0SPCEIEIQwRGxo7EwpELIYSARmggpVQlTdXN1ThfdR6bTmxCZWMl9Fo9ModmYtn4ZX6V\nPG+z+eRmVVEMV+mx6QAAo96IzKRMv5/Zvipe28/mO1O/g4/PfIzkqGQkRSb5/TwiUuP0PCIiInJT\nVFeEN4+8qZwLITA8ejiEEMo/3sxImQEASAhP8Di60XY9WGanzgbgnCZ4Z9adqmtajVZJgEbEjFBd\nq2muwZe5XyoFF6x2K/bm70VORY7f7y6oKfCaMJn0JkxOmOz3s1y5JoKu4sPjsXbaWixOX9yl5xKR\nU9//6yAiIqJBxmKzwOawea0kFwiny06rzjOHZvo9HW35+OWYnjIdcWFxePvo227XF45c2CMxdtWk\nhEm4d+a9CNGGID483ms/IQRunXwr/nHsHwCAnRd3eixCcb7yPMaYx3T4Xk97MbWtU0qLTsOctDl+\nr7dqz9v+S0TUM5g0ERERBZnFZsFze55DaUMphkUNQ2lDKWx2G9ZNW4f0uPSAxlLeUA6dRocDhQdU\n7YvSF/n9DCGEMhXM7lBX27t54s19ovBASlSKX/3aF1Ooaqpy63Og4AAWj1rc4dTE90+9rzqflToL\ny8Yt8yuOjhj1xh55DhF5xqSJiIgoyD4+8zFKG0oBAJdqLintu/J2BTRpOl5yHG8decut/ZEFj/gs\nBe5LbFgszlVe3oOoP6x5chVtjPZ6zaAzwGKzoMHagJK6EiRHeS+0YLFZlP2r2vTk6BBHmoh6F9c0\nERERBZFDOrA3f6/Ha9ll2ZBSBiSOOkudx4QpITyhywkTcHn9UJvY0FgvPfumSGOk12ujYi+XAN9+\nYbvbqJqryib3jWddN9ntLnOYuceeRUTumDQREREFQUVjBX6//ff45ae/9NmvvqU+IPE8+fWTHtu7\nO5UuITwBd15xJ2JCYzB16FQMixrWrecFmkZocN+s+9zar0i+AmbT5UTleMlx/OqzX6GgpsCtb1Fd\nEZ7d/axbu8Xec5vlRhojcf2Y65EYkRjwEu5EgwGTJiIioiD4MvdLt/2Cxg0Zh2tHX6tqK60v7fVY\nyhvK0WJv8XitJ9YfjYobhR9f9WPcMvmWbu1tFCxJkUluBSBunnAzJiVMglao96n66sJXbvd7q5bX\nfr1Ud81Nm4v7Z9/v1wbDRNQ5/WtiMRER0QBxsPCg6nxiwkTcOvlW6DQ6FNQW4ETJCQDAl+e/RK2l\nFl/mfomqpipohAYajQahulBMT5mOBSMXdDuW8sZyr9eMOhYYAIDF6Yux8fhGAMCPr/qxUuzigSsf\nwFM7n1L6tf3cXNVb3EcLEyMSMXXo1N4LmIh6FJMmIiKiAGpoacDmk5vd2l2nVCVFJCm/fOdW5iK3\nMle5Zpd2wOEsLPBpzqcYYx7T7U1Lfa3F6cl1N/1ZZlImpg6d6jZSZjaZMTlxMo4VH3Oee1hb1GBt\nUI7XZq5FWkwaQrQh/XLUjWiw4vQ8IiKiANl+fjt+8+VvcLL0pKq9fdnpK4df6fczs8uyfV7Pr8nH\npzmforzB+2hSs61ZOW5fipsjTZd5S3JuGHuDcuyaIAHODXAvVF1QziMMETDoDEyYiPoZjjQREREF\nyO683R7bJydOVp172+D0wTkPItoYjf0F+/Fh9ocAnElRGyklzledR0NLA2wOGy5WX1TW03yZ+yUe\nW/wY9Fq923NdCxIkRyarnhmi69pmq4NJeEg4dBodbA4bmqxNeG7Pc5CQqu+xTTA3LCairmPSRERE\nFABSSq+V8EL1oW5tJr1JNWoxNGIohpiGAABGxIxQ2k+Xn4bFZoFOo8Orh15FTkWO1xi2nduGJWOW\nuLVbbJeTJqPOiInxE3Gi9ARC9aHISMzo+MMNckIImE1mFNcVA1DvtdWep581EfV9nJ5HRETUyxzS\ngc/OfQaHdLhdizJGQSPc/zi+fcrtqvOFIxcqx2aTWVW1bVfeLpwsPekzYQKcewl50mK7XDnPoDPg\n1oxbcecVd+JHc36kJGrkW0J4Qod9zGFmr6OIRNS3caSJiIioF50uO41XD72qatNr9QjVhaLZ1ozb\nM273eN/I2JGYP2I+tl/YjqmJUzEhfoJyTafRITkyGXk1eQCAM2VngHa5TUZiBqKN0W6JkpTSbT2N\n65omg9YAnUaHUXGjQP6LNka7tUUYIrB0zFIkRiTiVNkpTIxnKXCi/opJExERUTdZ7VZUNlUi3hSv\nJCSNLY14cf+LKK4vdus/NHwo7pp+FwBAq9G6XW9z7ehrsSh9EXQa9z+ub59yO36//fcAgIqmCjRb\nLyc+S0YvwbwR8wC4jy7VWmrd9gdqsjUpx0Y9Cz90RYQhQnVuCjHh3pn3Kt91fHh8MMIioh7C6XlE\nRETdUN1UjSe/fhJP73oaH535CIBzOt4rh17xmDABQFhIGLQarc+EqY2nhAlwFh9QEjRro2r9k+u6\nmfb7OLXfHwpQ7yMUHhLeYUzkrv0mwI/Mf6THN68louBh0kRERNQNOy/uRK2lFoBzbVFVUxUuVl/0\nWDmtTU+sE9JqtAjThwFwTrmraKxQrrmWCZ+XNg+p0anK+fGS48pxXnUeXj/0Os5XnVfa2o+YkH/a\n72fFkuJEAwuTJiIiGtSsdisuVl9EcV0xpJSdvr+wrlA5llIipyIHRXVFqj7/Mec/sCh9EQBAr9Fj\n5rCZ3Qu6VUTI5QSnrKFMOXYdaTLoDFg/bb1yXlpfqpQmf37f8zhVdkr1TI40dc0Y8xgl4eypny8R\n9R1c00RERIOWlBKvHHxFGWlJjkzGmsw1fo+2SClRWl+qasurzlONMiwduxRmkxkLRixASmQK4sLi\nEBMa0yPxhxvCgdaZdU3Wy+uSQnXqstYGnQEGnQEWmwUO6UCzrRnbzm1zSxI1QqOMXlHn6LV6/HD2\nD1FYW4j02PRgh0NEPYwjTURENGhdqL6gmppWUFuANw6/4deIk0M6cLT4KBqtjar2g4UHcaDggHKe\nGJ4IwDmdbuyQsTCbzD0UvfdRofbrawCokqHT5aeRW5nr1iczKZPTyrohPCQcY8xj/FqrRkT9C0ea\niIhoUGpoacAL+15wa79UcwmbTmzCykkrvd57qPAQ3j/1PlrsLV77tEmI6Hj/nq7yNiLmaQPVUH0o\nqpqqAAD/PPZPpT01KhUbZmxAZVMlYkNjeydQIqJ+jiNNREQ0KPnaCPZg4UEcLT7q8ZqUEh+f+div\nhAno3TVC3p7tKWnyNu1u9vDZEEIgLiyOo0xERF4waSIiokGptOHyWqRQfSgemvuQ6vrWs1s9TtOr\naqpCfcvlEt3mMLPXhf83jLuhh6L1LNzgOWnSCPc/3j0lUgAw1jy2R2MiIhqIOD2PiIgGJddqc0vH\nLkVsWCxumnATNp/cDOByctQ2BS67LBsfnPoA1c3Vyn2j4kbhzivuhEM6sDd/r1uSNTVxaq9+hvYF\nH3zxNNK0bto6j+ufiIhIjSNNREQ0KNVZ6pTjGKOzmt30lOmqKW9t1eaqm6rx2qHXVAkTACSEO9cr\naYQGJr1Jde1bE7+FsJDerUTXmYTH00hTpCGyJ8MhIhqwONJERET9jkM6ICC6tQbHNWlyLagQbghX\npt89tfMpn89w3aT2qrSr8NGZjwA4S5dfkXxFl2Pzl6ekydt34mmkydv0PiIiUmPSRERE/crRoqPY\ndGITUqNTsXrKahj1Rr/vtdgs+NeJf+FEyQlVu2vSZND6P3ozLGqYcjxn+ByE6kNRUFuAWcNm+f2M\n7vAU65LRSzz29ZQ0cU8mIiL/cHoeERH1G0eLjuKdY+/A6rDiXOU5bDmzpVP3v3nkTbeEKUQbohqx\n8XfKW2JEIhIjEpVzIQSuSL4Cy8cvR3x4fKfi6iqjTp0wXpF8Ba5Ku8pj3/YJUog2xGPBCCIicsf/\nWxIRUb9gc9iw6eQmVdvBwoOw2q1e75FSorC2EIcKD+HpXU97LDOeFJmkOtdr9G59PK39+faUb/sb\neq8J0YWozn1Vwmtfnlyi4w18iYjIidPziIioX6htrnVLkKSUyK3Mxdgh7snC4aLD+Hf2v9FobfT6\nzKERQ7E2c62qrbKpUnUeZYzCXVl34X++/h+lbVbqLMSGBX8jWJ1G/ce4r+l27ZNDX8kmERGpMWki\nIqJ+ocZS47H91UOv4q6suxBhiIDZZAYAnK86j38e+6fP5z1x7RMe22uba1XnD8972K1PiCbEra0v\niDJGeb0mhECEIUJVAIOIiPzDpImIiPokh3SgsLYQ+wv2o6C2AIW1hV77vrD/Beg0Ojw450FYbBa8\nsO8Fn8+eP2K+12vXjL5G2atp6dilSntcWBwqGisAAKPNozvzUXrV8vHLsfXsVmQmZXY4+tV+ZIqI\niPzD/3sSEVGftOn4JhwqOuTxWmp0KvKq81RtNocNf9zxR4/9JydOxm2Tb8OOCztQZ6nD3OFzvb53\nytApqGmugUZoMDt1ttJ+e8bt+PjMx0iJSsHI2JFd+ES9Y+awmZiRMsOv8ush2r45QkZE1NcxaSIi\noj5HSoljJcc8XtNr9Fg5cWWHeyi5mp48HUIIzBsxr8O+IdoQXD3qarf2pMgkfDfru36/M5D83a9q\ndNxolNSXALi8MS8REXWMSRMREfU5NocNNodNOV8wcgHGmMfgYtVFpMWkwWwyQ6fRqfr40rbWabBb\nlL4IF6ovoN5Sj1WTVgU7HCKifoNJExER9TnNtmbl2KQ34ZpR1wAAhkcPV9p9JUyj4kbhQtUFmEJM\nyErO8lkgYTAx6Ay4d+a9kFL6PTpFRERMmoiIqA9wSAd2XtwJu8OOuWlzYbFZlGsGvX+bzQLAsnHL\nMCt1Vm+EOKAwYSIi6hwmTUREFHSHCg/h4zMfA3DuNeS6p5BRZ/TrGUadkQkTERH1Ck2wAyAiItp0\nYpNy/N6p91DdXK2c+5s03TThph6Pi4iICGDSREREfdBbR95SjkN1oR32T4lKwaSESb0ZEhERDWJM\nmoiIKGiklKoEyROj3vNI080TbgYARBoi8d0rvst1OkRE1Gu4pomIiIImryYPx0uO++wTY4zx2J6V\nkoX0uHSEh4RDr9X3RnhEREQAmDQREVEQnSk/02Gf6NBor9diQj0nVERERD2J0/OIiChoGlsaO+wT\nFxYXgEiIiIi8Y9JERERB02RrUo5vnXwr0mLS3PoMixoWwIiIiIjcMWkiIqKgabY1K8dGnRGZSZmq\n68vGLWOBByIiCjomTUREFDQWq0U5NuqNmBQ/CeEh4QAAg86AKUOnBCs0IiIiBQtBEBFR0LhOzzPq\njDDqjXhkwSMAnOXIOcpERER9AZMmIiIKqMaWRrx88GU025pR0VihtLffxJYJExER9RVMmoiIKKBO\nlp5EQW2BW7u3TWyJiIiCjWuaiIgooPJr893aIg2RCNGGBCEaIiKijjFpIiKigArVh7q1saw4ERH1\nZUya/JSXl4dz584FOwwion7PYrO4tV05/MogREJEROQfrmny05EjRwAAw4YNQ0gIp5AQEXWVa9L0\nrYnfwtShU6HVaIMYERERkW8cafKDlNLjMRERdU5lYyUOFx1WzkP1oUyYiIiozwtY0iSEeEkIUSqE\nOO7l+reFEEeFEMeEELuEEFNcrl0nhDgthMgRQvwsUDG3cTgcgX4lEdGAc6n6Ep7a+ZSqzaA1BCka\nIiIi/wVypOllANf5uH4ewHwp5WQAvwbwPAAIIbQA/gLgegATANwhhJjQu6GquSZNTKCIiLrmZOlJ\nOKT6/6GsmEdERP1BwJImKeV2AJU+ru+SUla1nn4DIKX1eAaAHCllrpSyBcDbAFb0arDt2O121zgD\n+WoiogHjQOEB1bleo4fZZA5SNERERP7rq4Ugvgfgo9bjZACXXK7lA5jp6SYhxAYAGwAgNTW1x4Jh\n0kRE1D0l9SVoaGlQzscPGY+5aXM9lh8nIiLqa/pc0iSEWAhn0jS3s/dKKZ9H67S+rKysHstuXJMm\nTs8jooFKSgkhRK88+1jxMdX5rRm3cmoeERH1G30qaRJCZAB4AcD1UsqK1uYCAK67Hqa0tgUMR5qI\naCBrsjbh1YOvoq6lDqunrEZSZFKPv2Nf/j7leHH6YiZMRETUr/SZkuNCiFQAmwCskVKecbm0D8Bo\nIcQIIUQIgNsBvB/I2Jg0UX9ld9hhtVuDHQb1cZ+c/QR5NXmoaqrCzos7e/z5Z8vPor6lXjnPSMzo\n8XcQERH1poCNNAkh3gKwAIBZCJEP4FEAegCQUj4H4FcA4gD8tXV6iE1KmSWltAkhfgjgEwBaAC9J\nKU8EKm5APSWPSRP1F7XNtfjrnr+ixd6C713xPSRHJQc7JOqjXEeBDhcdxi2Tb+nR5x8sPKg6jw2L\n7dHnExER9baAJU1Syjs6uH4XgLu8XNsCYEtvxOWPvramyeFwQEoJrZYbQpJ323K3oc5SBwD4656/\nIvODCfUAACAASURBVN4Uj9un3I6E8IQgR0Z9RU5FDi7VXFK1aUTPT0BotDb2+juIiIh6E//k8oPN\nZlOOgz3SJKXEZ599hs8//zzosVDfdrHqouq8tKEUu/N2Byka6mtyK3Px8sGX8VnOZ6r29vso9QSd\n5vLfz9004aYefz4REVFvY9LkB4vFohwHO1Gx2WywWCywWCyqZI6oPaPO6NZWVFcUhEioLzpQcMDr\n/89qmmt65B1N1iacKDmBisYKpY37MhERUX/EpMkPLS0tynGwp+c1NTUpx1YrF/iTDx4qR/fGKAL1\nT66FGdr7/fbfo9na3K3nSynx8sGX8eaRN1HWUKa0h+nDuvVcIiKiYGDS5Ie+NNLkmjTZbDbU1dUh\nJycn6Mkc9T2uG4m2KawtDEIk1Be12Fp8Xt+Tv6dbz6+11CK/Jt+tPVTHzWyJiKj/6VP7NPVVfSFp\nqq2txcGDBxEeHq60Wa1W7Nq1CwCg0+mQlpYWlNiob/JWavx81XmMiBkR4GioIw7pQE5FDqKMUQEp\n1tFi9500dXeKXkGt5+30TCGmbj2XiIgoGDjS5AfXtUPBGtE5d+4c6urqUFR0eU1KZWWlctzQ4D6q\nQIOb1eE5aWpfIIL6hj2X9uCVg6/gmd3PoLKxsuMbuslit/i83t39vdpX5QOc+zNpNaz6SURE/Q+T\nJj+4ji4Fa6RJo3H/UWVnZyvHOh0HDUnN9ZfexPBE5bijEQYKjg+zPwTg/H/MF7lf9Pr7OvrvwObo\nXqGZS9XqpCklKgU3jLuhW88kIiIKFv6m7YeONrdta3M4HD2+d5LdbseOHTtQV1fnsx+LQhDg/EX4\naNFRmEJMyi+9QghMS56GLaedW511NMJAwdfdhMUfHSVNR4uPYlbqLAyPHu73M8sbyvHRmY9Q2ViJ\n0oZSpf2n836KSGNkl2P9/+zdeXRb13ku/GdjJkASnGdRokRSs0QNlCxbliVLlofESZw4SZ0buZmc\n3pXB7W1vp6/f/XrT9K6mXe1dTdqkddI242rsOLETu3FsJ7ZlKZZszbNIcZIoTuJMkAQJEMD+/oDO\n4TnAAQmA4CQ+v7W4TJxzAGxosM7Dd+93ExERzTeGpjhog1Lk9LzW1lacP39efbxv3z7duqOZ8ng8\n0wYmQN/hTyGlhBDhFmrj4+MYHx9HVlZWysZGC88r9a/gZNtJ3TGryQq7xa4+nq4BQKR+bz9eb3wd\nvaO9qCmuwe4Vu1MyVopNu6/RbAjJUFzT77594tv4Pwf/T9yv+0bTG6jrqdMdc1ldDExERLToMTTF\nIValKRQK6QITEA5R69atS9l7j4wYtwWuqKhAcXExQqEQ3n33XYyPT7YHbmtrg81mw8WLF+F2u7Ft\n2zYcOXIEPp8v5aGOFg6v34sz7WeijlvNVtjMNvVxZKWpbagNZzvPone0F/tW7sOK7BWT1wZ8+Jf3\n/gXeCS+A8D5PZe4y3TU0c2c7zuoez3Zoervl7biv/dHZH+GTWz4Z17Vdw11Rx4ozi+N+LyIiooWK\noSkOsdY0DQ4ORl2b7PQ8KSWCwWDU2iRtlclms6kVpZKSEuTk5MDrDd/M9vX1QUqJoaEhnD07eQPm\n9Xrx5ptvqh0Au7u7GZruUGc7zyIog1HHbWYb7GZNpUkzLaulvwX/fvrf1T/XjX2N+KPdf4QcZw56\nR3vxg7M/UAOT4kzHGYamFKrvqcdPL/1Ud2y2QpOUEr+4+ouoauRUrvZcxcDYALLTsqe8zhfw6abk\nAYBJmPBA5QNJjZWIiGghYWiKQ6zpeUZVIKOGDfG4dOkSrl+/jj179sDtdmNsbAw3b95EU1MTAGD7\n9u2QUuL06dMAAJcr3LY3LS0NJpMJoVAIzc3N6nEtJVgBwM2bN1FRUaFO26M7x/HW44bHrSYrbBZN\npSkwWWk63HI4ap3eMyeewVO1T+FfT/wrxibGEKmupw4hGYJJzKyPjHb66FJmFGBmo8NcIBTA0etH\no97v/lX3Y3xiHBn2DOxesRtfe/trUXt8tXvao0JTIBRASIZgMVkw6h/F197+mnou056JD6z9ADLt\nmSh1l6b8sxAREc01hqY4xJqeZ9TmO9lK0/Xr19X/bt68GadOndJVsjIyMmCz2ZCeno7CwkLY7eHK\ngRACDocDXq8Xw8PD01aRPB6PYUWLFrdgKIiBsQHDc92j3YaVJq/fi6b+pqjrR/wjeKX+FTUwWUwW\n7F25F0dajsAf9GPUP4ofnP0BPrj2gzGrD16/F6/Uv4I0axoeXv0wTMIEX8CHw82H0TrUit7RXowH\nxrG2YC0e3/A4WgdbUZReBKfNOcNficVn2B+9ZjFWu/hkhWQI3zj2DfR5+3THa8tqsX/Vft2xT2/7\nNE7cPIFLty6pVcYfn/8x/mLvX6i/P2+3vI3XG14HANgt9qi1nvtW7sPagrUp/QxERETziXfOcYg1\nPU+7jkiRbKVJoYShyKl/LpcLQgjs27cv6jkbNmzAiRMn4PP5Yu4jtX//fhw/fhxerxfj4+NxT9Gb\nmJiAxWJhRWCBGwtEV4S0HBbH5LW3w9D1wevqn+fijGJ0Dk/uAVbfW69+/1D1Q9hVvguecQ9OtJ0A\nADT0NuBH536EL+/6su59pJToGunCW01v4XL3ZQBAUUYRytxl+Maxb0SN62LXRbT0t2DEP4JcZy6e\nvvvpWV/Ps9BEVnWAme+RFKnT0xkVmNJt6Xi4+uGoa4szivHBdR9EZW4l/vP8f6rHf3b5ZzhYdRCv\n1L+Cxr5G9bi2cgmEQ1RtWW1Kx09ERDTfltbdSZJiVZpidaxLlPY5Npst6nxVVdWUoUUJWuPj47qN\neBUZGRlwOp1qRcrn88UVmsbGxvCb3/wGRUVFqK3lTdBCNj4RHeAV20q3IdORCSEEpJTw+Dw41X4K\nL15+Ub2mIL0Aboc7qvMZAJRllgEA7ll+D063n1bXTXUNd8EX8Kmd+UIyhOcvPo8LXRd0z3/h8gtT\njn3EH57m2uftQ1NfE1bnr47jE985xgPRv3epbjnuD0X/v+r37/59XVfFSJW5lbrHdT11hn8+In12\n22f5QxYiIrrjcHPbOMRa06SEppycHMPz8Robm6wS
Download .txt
gitextract_2mw6s78b/

├── EnvTestCRC_DRL.ipynb
├── EnvTestCRC_RPG.ipynb
├── EnvTestFuturesNews_DRL.ipynb
├── EnvTestFuturesNews_RPG.ipynb
├── EnvTestStock_DRL.ipynb
├── EnvTestStock_RPG.ipynb
├── README.md
├── agents/
│   ├── __init__.py
│   ├── agent.py
│   ├── drl_agent.py
│   ├── drl_news_agent.py
│   ├── rpg_agent.py
│   └── rpg_news_agent.py
├── crypto_currency/
│   ├── DDPG.ipynb
│   ├── DDRPG_shareV.ipynb
│   ├── DQN.ipynb
│   ├── DataUtils.py
│   ├── DirectRL.ipynb
│   ├── HuobiServices.py
│   ├── PolicyGradient.ipynb
│   ├── PortfolioSelection.ipynb
│   ├── RecurrentPG.ipynb
│   ├── RecurrentPG_shareV.ipynb
│   └── Utils.py
├── env/
│   ├── __init__.py
│   ├── crc_env.py
│   ├── futures_env.py
│   ├── stock_env.py
│   └── zipline_env.py
├── history/
│   ├── DRL_PairsTrading.py
│   ├── DRL_Portfolio.py
│   ├── DRL_Portfolio_Alpha.py
│   ├── DRL_Portfolio_Isolated.py
│   ├── DRL_Portfolio_Isolated_Simple.py
│   ├── PairsTradingBacktest.py
│   ├── PairsTradingTutorial.ipynb
│   ├── PortfolioBacktest.py
│   ├── PortfolioBacktestAlpha.py
│   ├── PortfolioBacktestIsoloated.py
│   ├── PortfolioBacktestNews.py
│   ├── PortfolioBacktestNewsAlpha.py
│   ├── PortfolioTutorial.ipynb
│   ├── Tutorial.ipynb
│   └── ZiplineTensorboard.py
├── model_archive/
│   ├── DRL_Portfolio_Highway.py
│   ├── DRL_Portfolio_Isolated.py
│   ├── DRL_Portfolio_Isolated_Hedge.py
│   ├── DRL_Portfolio_Isolated_Simple.py
│   ├── DRL_Portfolio_Simple.py
│   ├── DRL_Portfolio_Whatever.py
│   ├── HedgeFundTradingExample.py
│   ├── HyperParameterTuning.py
│   ├── ResultAnalysis.ipynb
│   ├── SimpleModel.py
│   ├── TradingExample.py
│   └── __init__.py
└── utils/
    ├── DataUtils.py
    ├── EnvironmentUtils.py
    ├── HuobiServices.py
    ├── SysUtils.py
    ├── ZiplineTensorboard.py
    └── __init__.py
Download .txt
SYMBOL INDEX (397 symbols across 35 files)

FILE: agents/agent.py
  class Agent (line 5) | class Agent(object):
    method __init__ (line 6) | def __init__(self):
    method trade (line 10) | def trade(self, state):
    method train (line 13) | def train(self):
    method load_model (line 17) | def load_model(self, model_path):
    method save_model (line 21) | def save_model(self, model_path):

FILE: agents/drl_agent.py
  class Actor (line 10) | class Actor(nn.Module):
    method __init__ (line 11) | def __init__(self, s_dim, b_dim, rnn_layers=1, dp=0.2):
    method forward (line 28) | def forward(self, state, hidden=None, train=False):
  class DRLAgent (line 42) | class DRLAgent(Agent):
    method __init__ (line 43) | def __init__(self, s_dim, b_dim, batch_length=64, learning_rate=1e-3, ...
    method _trade (line 57) | def _trade(self, state, train=False):
    method trade (line 62) | def trade(self, state, train=False):
    method train (line 67) | def train(self):
    method reset_model (line 78) | def reset_model(self):
    method save_transition (line 85) | def save_transition(self, state, diff):
    method load_model (line 96) | def load_model(self, model_path='./DRL_Torch'):
    method save_model (line 99) | def save_model(self, model_path='./DRL_Torch'):

FILE: agents/drl_news_agent.py
  class Actor (line 10) | class Actor(nn.Module):
    method __init__ (line 11) | def __init__(self, s_dim, b_dim, n_dim, rnn_layers=1, dp=0.2):
    method forward (line 33) | def forward(self, state, news, state_hidden=None, news_hidden=None, tr...
  class DRLAgent (line 52) | class DRLAgent(Agent):
    method __init__ (line 53) | def __init__(self, s_dim, b_dim, n_dim, batch_length=64, learning_rate...
    method _trade (line 72) | def _trade(self, state, news, train=False):
    method trade (line 81) | def trade(self, state, news, train=False):
    method train (line 87) | def train(self):
    method reset_model (line 103) | def reset_model(self):
    method save_transition (line 113) | def save_transition(self, state, news, diff):
    method load_model (line 127) | def load_model(self, model_path='./DRL_Torch'):
    method save_model (line 130) | def save_model(self, model_path='./DRL_Torch'):

FILE: agents/rpg_agent.py
  class Actor (line 9) | class Actor(nn.Module):
    method __init__ (line 10) | def __init__(self, s_dim, a_dim, b_dim, rnn_layers=1, dp=0.2):
    method forward (line 29) | def forward(self, state, hidden=None, train=False):
  class RPGAgent (line 43) | class RPGAgent(Agent):
    method __init__ (line 44) | def __init__(self, s_dim, a_dim, b_dim, batch_length=64, learning_rate...
    method _trade (line 61) | def _trade(self, state, train=False):
    method trade (line 69) | def trade(self, state):
    method train (line 74) | def train(self):
    method reset_model (line 90) | def reset_model(self):
    method save_transition (line 99) | def save_transition(self, state, action, reward, next_state):
    method load_model (line 116) | def load_model(self, model_path='./RPG_Torch'):
    method save_model (line 119) | def save_model(self, model_path='./RPG_Torch'):

FILE: agents/rpg_news_agent.py
  class Actor (line 9) | class Actor(nn.Module):
    method __init__ (line 10) | def __init__(self, s_dim, a_dim, b_dim, n_dim, rnn_layers=1, dp=0.2):
    method forward (line 36) | def forward(self, state, news, news_hidden=None, state_hidden=None, tr...
  class RPGAgent (line 56) | class RPGAgent(Agent):
    method __init__ (line 57) | def __init__(self, s_dim, a_dim, b_dim, n_dim, batch_length=64, learni...
    method _trade (line 78) | def _trade(self, state, news, train=False):
    method trade (line 86) | def trade(self, state, news, train=False):
    method train (line 92) | def train(self):
    method reset_model (line 113) | def reset_model(self):
    method save_transition (line 123) | def save_transition(self, state, action, reward, next_state, news):
    method load_model (line 143) | def load_model(self, model_path='./RPG_Torch'):
    method save_model (line 146) | def save_model(self, model_path='./RPG_Torch'):

FILE: crypto_currency/DataUtils.py
  function generate_tech_data (line 5) | def generate_tech_data(stock, open_name, close_name, high_name, low_name...
  function kline (line 35) | def kline(asset, interval='15min', count=500):

FILE: crypto_currency/HuobiServices.py
  function get_kline (line 16) | def get_kline(symbol, period, size=150):
  function get_depth (line 32) | def get_depth(symbol, type):
  function get_trade (line 46) | def get_trade(symbol):
  function get_ticker (line 58) | def get_ticker(symbol):
  function get_detail (line 70) | def get_detail(symbol):
  function get_symbols (line 81) | def get_symbols(long_polling=None):
  function get_accounts (line 96) | def get_accounts():
  function get_balance (line 106) | def get_balance(acct_id=None):
  function send_order (line 125) | def send_order(amount, source, symbol, _type, price=0):
  function cancel_order (line 154) | def cancel_order(order_id):
  function order_info (line 166) | def order_info(order_id):
  function order_matchresults (line 178) | def order_matchresults(order_id):
  function orders_list (line 190) | def orders_list(symbol, states, types=None, start_date=None, end_date=No...
  function orders_matchresults (line 223) | def orders_matchresults(symbol, types=None, start_date=None, end_date=No...
  function withdraw (line 255) | def withdraw(address, amount, currency, fee=0, addr_tag=""):
  function cancel_withdraw (line 278) | def cancel_withdraw(address_id):
  function send_margin_order (line 300) | def send_margin_order(amount, source, symbol, _type, price=0):
  function exchange_to_margin (line 330) | def exchange_to_margin(symbol, currency, amount):
  function margin_to_exchange (line 347) | def margin_to_exchange(symbol, currency, amount):
  function get_margin (line 362) | def get_margin(symbol, currency, amount):
  function repay_margin (line 376) | def repay_margin(order_id, amount):
  function loan_orders (line 388) | def loan_orders(symbol, currency, start_date="", end_date="", start="", ...
  function margin_balance (line 412) | def margin_balance(symbol):

FILE: crypto_currency/Utils.py
  function http_get_request (line 40) | def http_get_request(url, params, add_to_headers=None):
  function http_post_request (line 60) | def http_post_request(url, params, add_to_headers=None):
  function api_key_get (line 80) | def api_key_get(params, request_path):
  function api_key_post (line 97) | def api_key_post(params, request_path):
  function createSign (line 113) | def createSign(pParams, method, host_url, request_path, secret_key):

FILE: env/crc_env.py
  class CryptoCurrencyEnv (line 13) | class CryptoCurrencyEnv(object):
    method __init__ (line 14) | def __init__(self, instruments,
    method reset (line 52) | def reset(self):
    method step (line 67) | def step(self, action):
    method _rebalance (line 80) | def _rebalance(self, action, current_price):
    method _get_normalized_state (line 97) | def _get_normalized_state(self):
    method get_meta_state (line 102) | def get_meta_state(self):
    method _get_reward (line 105) | def _get_reward(self, current_price, next_price):
    method _init_market_data (line 115) | def _init_market_data(self, data_name='crc_market_data.pkl', re_downlo...
    method get_summary (line 132) | def get_summary(self):
    method _pre_process (line 139) | def _pre_process(market_data, open_c, high_c, low_c, close_c, volume_c):
    method kline (line 146) | def kline(instrument, base_currency='btc', interval='60min', count=2000):
    method klines (line 161) | def klines(instruments, base_currency='btc', interval='60min', count=2...
    method _get_indicators (line 165) | def _get_indicators(stock, open_name, close_name, high_name, low_name,...

FILE: env/futures_env.py
  class FuturesEnv (line 9) | class FuturesEnv(object):
    method __init__ (line 10) | def __init__(self, instruments,
    method reset (line 43) | def reset(self):
    method step (line 58) | def step(self, action):
    method _rebalance (line 71) | def _rebalance(self, action, current_price):
    method _get_normalized_state (line 88) | def _get_normalized_state(self):
    method get_meta_state (line 93) | def get_meta_state(self):
    method _get_reward (line 96) | def _get_reward(self, current_price, next_price):
    method _init_market_data (line 106) | def _init_market_data(self, data_name='futures_market_data.pkl', pre_p...
    method get_summary (line 127) | def get_summary(self):
    method _pre_process (line 133) | def _pre_process(self, market_data, open_c, high_c, low_c, close_c, vo...
    method _get_indicators (line 148) | def _get_indicators(security, open_name, close_name, high_name, low_na...

FILE: env/stock_env.py
  class StockEnv (line 9) | class StockEnv(object):
    method __init__ (line 10) | def __init__(self, instruments,
    method reset (line 43) | def reset(self):
    method step (line 58) | def step(self, action):
    method _rebalance (line 71) | def _rebalance(self, action, current_price):
    method _get_normalized_state (line 88) | def _get_normalized_state(self):
    method get_meta_state (line 93) | def get_meta_state(self):
    method _get_reward (line 96) | def _get_reward(self, current_price, next_price):
    method _init_market_data (line 106) | def _init_market_data(self, data_name='stock_market_data.pkl', pre_pro...
    method get_summary (line 131) | def get_summary(self):
    method _pre_process (line 137) | def _pre_process(self, market_data, open_c, high_c, low_c, close_c, vo...
    method _get_indicators (line 152) | def _get_indicators(security, open_name, close_name, high_name, low_na...

FILE: env/zipline_env.py
  class AgentTrader (line 55) | class AgentTrader(TradingAlgorithm):
    method __init__ (line 56) | def __init__(self, model, pre_defined_assets, equity_data, other_data,...
    method initialize (line 76) | def initialize(self):
    method handle_data (line 80) | def handle_data(self, data):
    method backtest (line 188) | def backtest(self, data):

FILE: history/DRL_PairsTrading.py
  class DRL_PairsTrading (line 33) | class DRL_PairsTrading(object):
    method __init__ (line 34) | def __init__(self, feature_number, object_function= 'sortino', dense_u...
    method init_model (line 80) | def init_model(self):
    method get_rnn_zero_state (line 83) | def get_rnn_zero_state(self):
    method _sortino_ratio (line 87) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 97) | def _sharpe_ratio(self, r, rf):
    method _add_dense_layer (line 101) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _add_gru_cell (line 106) | def _add_gru_cell(self, units_number):
    method build_feed_dict (line 109) | def build_feed_dict(self, batch_F, batch_Z, keep_prob, fee, rnn_hidden...
    method change_drop_keep_prob (line 119) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method train (line 123) | def train(self, feed):
    method load_model (line 126) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 129) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 135) | def trade(self, feed):

FILE: history/DRL_Portfolio.py
  class DRL_Portfolio (line 33) | class DRL_Portfolio(object):
    method __init__ (line 34) | def __init__(self, feature_number, asset_number, object_function='sort...
    method init_model (line 83) | def init_model(self):
    method get_session (line 92) | def get_session(self):
    method _add_dense_layer (line 95) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 100) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 110) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 114) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 117) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 120) | def build_feed_dict(self, batch_F, batch_Z, keep_prob=0.8, fee=1e-3, t...
    method change_tao (line 129) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 133) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method train (line 137) | def train(self, feed):
    method load_model (line 140) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 143) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 149) | def trade(self, feed):

FILE: history/DRL_Portfolio_Alpha.py
  class DRL_Portfolio (line 33) | class DRL_Portfolio(object):
    method __init__ (line 34) | def __init__(self, feature_number, asset_number, object_function='sort...
    method init_model (line 83) | def init_model(self):
    method get_session (line 92) | def get_session(self):
    method _add_dense_layer (line 95) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 100) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 110) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 114) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 117) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 120) | def build_feed_dict(self, batch_F, batch_Z, keep_prob=0.8, fee=1e-3, t...
    method change_tao (line 129) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 133) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method train (line 137) | def train(self, feed):
    method load_model (line 140) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 143) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 149) | def trade(self, feed):

FILE: history/DRL_Portfolio_Isolated.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, action_netw...
    method init_model (line 137) | def init_model(self):
    method get_session (line 140) | def get_session(self):
    method _add_dense_layer (line 143) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 148) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 158) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 162) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 165) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 168) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 179) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 183) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method train (line 187) | def train(self, feed):
    method load_model (line 190) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 193) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 199) | def trade(self, feed):

FILE: history/DRL_Portfolio_Isolated_Simple.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, action_netw...
    method init_model (line 179) | def init_model(self):
    method get_session (line 182) | def get_session(self):
    method _add_dense_layer (line 185) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 190) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 200) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 204) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 207) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 210) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 221) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 225) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 229) | def get_summary(self, feed):
    method train (line 232) | def train(self, feed):
    method load_model (line 235) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 238) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 244) | def trade(self, feed):

FILE: history/PairsTradingBacktest.py
  function generate_tech_data (line 21) | def generate_tech_data(p1_df,p2_df):
  function batch_nomorlize (line 42) | def batch_nomorlize(sample):
  function initialize (line 48) | def initialize(context):
  function before_trading_start (line 63) | def before_trading_start(context, data):
  function my_round (line 90) | def my_round(x):
  function handle_data (line 98) | def handle_data(context, data):

FILE: history/PortfolioBacktest.py
  function generate_tech_data (line 30) | def generate_tech_data(stock):
  function batch_nomorlize (line 46) | def batch_nomorlize(f_data):
  function initialize (line 52) | def initialize(context):
  function before_trading_start (line 114) | def before_trading_start(context, data):
  function handle_data (line 157) | def handle_data(context, data):

FILE: history/PortfolioBacktestAlpha.py
  function generate_tech_data (line 29) | def generate_tech_data(stock):
  function batch_nomorlize (line 45) | def batch_nomorlize(f_data):
  function normallize_all (line 51) | def normallize_all(f_data):
  function initialize (line 55) | def initialize(context):
  function before_trading_start (line 126) | def before_trading_start(context, data):
  function handle_data (line 186) | def handle_data(context, data):

FILE: history/PortfolioBacktestIsoloated.py
  function generate_tech_data (line 32) | def generate_tech_data(stock, open_name, close_name, high_name, low_name):
  function batch_nomorlize (line 77) | def batch_nomorlize(f_data):
  function normalize_all (line 83) | def normalize_all(f_data):
  function generate_stock_features (line 87) | def generate_stock_features(history_data):
  function generate_index_features (line 101) | def generate_index_features(index_data):
  function initialize (line 113) | def initialize(context):
  function before_trading_start (line 271) | def before_trading_start(context, data):
  function handle_data (line 345) | def handle_data(context, data):

FILE: history/PortfolioBacktestNews.py
  function generate_tech_data (line 30) | def generate_tech_data(stock):
  function batch_nomorlize (line 46) | def batch_nomorlize(f_data):
  function initialize (line 52) | def initialize(context):
  function before_trading_start (line 123) | def before_trading_start(context, data):
  function handle_data (line 168) | def handle_data(context, data):

FILE: history/PortfolioBacktestNewsAlpha.py
  function generate_tech_data (line 29) | def generate_tech_data(stock):
  function batch_nomorlize (line 45) | def batch_nomorlize(f_data):
  function initialize (line 51) | def initialize(context):
  function before_trading_start (line 123) | def before_trading_start(context, data):
  function handle_data (line 168) | def handle_data(context, data):

FILE: history/ZiplineTensorboard.py
  class TensorBoard (line 11) | class TensorBoard(object):
    method __init__ (line 29) | def __init__(self, log_dir='./logs', max_queue=10, flush_secs=120):
    method log_dict (line 37) | def log_dict(self, epoch, logs):
    method log_algo (line 52) | def log_algo(self, algo, epoch=None, other_logs={}):

FILE: model_archive/DRL_Portfolio_Highway.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, object_func...
    method init_model (line 175) | def init_model(self):
    method get_session (line 178) | def get_session(self):
    method get_parameters (line 181) | def get_parameters(self):
    method _add_dense_layer (line 184) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 189) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 199) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 203) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_highway_lstm_cell (line 206) | def _add_highway_lstm_cell(self, units_number, activation=tf.nn.tanh):
    method _add_lstm_cell (line 216) | def _add_lstm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 225) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 236) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 240) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 244) | def get_summary(self, feed):
    method train (line 247) | def train(self, feed):
    method load_model (line 250) | def load_model(self, model_file='./trade_model_checkpoint'):
    method save_model (line 253) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 259) | def trade(self, feed):

FILE: model_archive/DRL_Portfolio_Isolated.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, action_netw...
    method init_model (line 137) | def init_model(self):
    method get_session (line 140) | def get_session(self):
    method _add_dense_layer (line 143) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 148) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 158) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 162) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 165) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 168) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 179) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 183) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method train (line 187) | def train(self, feed):
    method load_model (line 190) | def load_model(self, model_file='./trade_model_checkpoint/trade_model'):
    method save_model (line 193) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 199) | def trade(self, feed):

FILE: model_archive/DRL_Portfolio_Isolated_Hedge.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, object_func...
    method init_model (line 193) | def init_model(self):
    method get_session (line 196) | def get_session(self):
    method get_parameters (line 199) | def get_parameters(self):
    method _add_dense_layer (line 202) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 207) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 217) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 221) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 224) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 227) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 238) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 242) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 246) | def get_summary(self, feed):
    method train (line 249) | def train(self, feed):
    method load_model (line 252) | def load_model(self, model_file='./trade_model_checkpoint'):
    method save_model (line 255) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 261) | def trade(self, feed):

FILE: model_archive/DRL_Portfolio_Isolated_Simple.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, object_func...
    method init_model (line 188) | def init_model(self):
    method get_session (line 191) | def get_session(self):
    method get_parameters (line 194) | def get_parameters(self):
    method _add_dense_layer (line 197) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 202) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 212) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 216) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 219) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 222) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 233) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 237) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 241) | def get_summary(self, feed):
    method train (line 244) | def train(self, feed):
    method load_model (line 247) | def load_model(self, model_file='./trade_model_checkpoint'):
    method save_model (line 250) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 256) | def trade(self, feed):

FILE: model_archive/DRL_Portfolio_Simple.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, object_func...
    method init_model (line 183) | def init_model(self):
    method get_session (line 186) | def get_session(self):
    method get_parameters (line 189) | def get_parameters(self):
    method _add_dense_layer (line 192) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 197) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 207) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 211) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_letm_cell (line 214) | def _add_letm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 217) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 228) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 232) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 236) | def get_summary(self, feed):
    method train (line 239) | def train(self, feed):
    method load_model (line 242) | def load_model(self, model_file='./trade_model_checkpoint'):
    method save_model (line 245) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 251) | def trade(self, feed):

FILE: model_archive/DRL_Portfolio_Whatever.py
  class DRL_Portfolio (line 68) | class DRL_Portfolio(object):
    method __init__ (line 69) | def __init__(self, asset_number, feature_network_topology, object_func...
    method init_model (line 190) | def init_model(self):
    method get_session (line 193) | def get_session(self):
    method get_parameters (line 196) | def get_parameters(self):
    method _add_dense_layer (line 199) | def _add_dense_layer(self, inputs, output_shape, drop_keep_prob, act=t...
    method _sortino_ratio (line 204) | def _sortino_ratio(self, r, rf):
    method _sharpe_ratio (line 214) | def _sharpe_ratio(self, r, rf):
    method _add_gru_cell (line 218) | def _add_gru_cell(self, units_number, activation=tf.nn.relu):
    method _add_highway_lstm_cell (line 221) | def _add_highway_lstm_cell(self, units_number, activation=tf.nn.tanh):
    method _add_lstm_cell (line 231) | def _add_lstm_cell(self, units_number, activation=tf.nn.tanh):
    method build_feed_dict (line 240) | def build_feed_dict(self, input_data, return_rate, keep_prob=0.8, fee=...
    method change_tao (line 251) | def change_tao(self, feed_dict, new_tao):
    method change_drop_keep_prob (line 255) | def change_drop_keep_prob(self, feed_dict, new_prob):
    method get_summary (line 259) | def get_summary(self, feed):
    method train (line 262) | def train(self, feed):
    method load_model (line 265) | def load_model(self, model_file='./trade_model_checkpoint'):
    method save_model (line 268) | def save_model(self, model_path='./trade_model_checkpoint'):
    method trade (line 274) | def trade(self, feed):

FILE: utils/DataUtils.py
  function generate_tech_data_default (line 14) | def generate_tech_data_default(stock, open_name, close_name, high_name, ...
  function generate_tech_data (line 52) | def generate_tech_data(stock, open_name, close_name, high_name, low_name...
  function batch_nomorlize (line 93) | def batch_nomorlize(f_data):
  function generate_stock_features (line 102) | def generate_stock_features(history_data, max_time_window=10):
  function generate_index_features (line 118) | def generate_index_features(index_data, max_time_window=10):
  function prepare_equity_data (line 130) | def prepare_equity_data(start_date, instruments, data_path='./data/equit...
  function prepare_index_data (line 151) | def prepare_index_data(start_date, equity_reference_index=None, data_pat...
  function prepare_news_data (line 180) | def prepare_news_data(reference_equity_data, data_path='data/news.csv'):
  function retrieve_equitys (line 191) | def retrieve_equitys(bundle, assets):

FILE: utils/EnvironmentUtils.py
  function build_backtest_environment (line 12) | def build_backtest_environment(star_date, end_date,capital_base=100000):

FILE: utils/HuobiServices.py
  function get_kline (line 16) | def get_kline(symbol, period, size=150):
  function get_depth (line 32) | def get_depth(symbol, type):
  function get_trade (line 46) | def get_trade(symbol):
  function get_ticker (line 58) | def get_ticker(symbol):
  function get_detail (line 70) | def get_detail(symbol):
  function get_tickers (line 81) | def get_tickers():
  function get_symbols (line 87) | def get_symbols(long_polling=None):
  function get_accounts (line 103) | def get_accounts():
  function get_balance (line 116) | def get_balance(acct_id=None):
  function send_order (line 135) | def send_order(amount, source, symbol, _type, price=0):
  function cancel_order (line 164) | def cancel_order(order_id):
  function order_info (line 176) | def order_info(order_id):
  function order_matchresults (line 188) | def order_matchresults(order_id):
  function orders_list (line 200) | def orders_list(symbol, states, types=None, start_date=None, end_date=No...
  function orders_matchresults (line 233) | def orders_matchresults(symbol, types=None, start_date=None, end_date=No...
  function withdraw (line 264) | def withdraw(address, amount, currency, fee=0, addr_tag=""):
  function cancel_withdraw (line 288) | def cancel_withdraw(address_id):
  function send_margin_order (line 311) | def send_margin_order(amount, source, symbol, _type, price=0):
  function exchange_to_margin (line 342) | def exchange_to_margin(symbol, currency, amount):
  function margin_to_exchange (line 360) | def margin_to_exchange(symbol, currency, amount):
  function get_margin (line 376) | def get_margin(symbol, currency, amount):
  function repay_margin (line 391) | def repay_margin(order_id, amount):
  function loan_orders (line 404) | def loan_orders(symbol, currency, start_date="", end_date="", start="", ...
  function margin_balance (line 428) | def margin_balance(symbol):

FILE: utils/SysUtils.py
  function init_account (line 24) | def init_account(access_key, secret_key):
  function http_get_request (line 41) | def http_get_request(url, params, add_to_headers=None):
  function http_post_request (line 61) | def http_post_request(url, params, add_to_headers=None):
  function api_key_get (line 81) | def api_key_get(params, request_path):
  function api_key_post (line 98) | def api_key_post(params, request_path):
  function createSign (line 114) | def createSign(pParams, method, host_url, request_path, secret_key):

FILE: utils/ZiplineTensorboard.py
  class TensorBoard (line 11) | class TensorBoard(object):
    method __init__ (line 29) | def __init__(self, session, log_dir='./logs', max_queue=10, flush_secs...
    method log_dict (line 38) | def log_dict(self, epoch, logs, model_summaries=None):
    method log_algo (line 55) | def log_algo(self, algo, model_summaries=None, epoch=None, other_logs=...
Copy disabled (too large) Download .json
Condensed preview — 62 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (17,942K chars).
[
  {
    "path": "EnvTestCRC_DRL.ipynb",
    "chars": 854683,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 3,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n "
  },
  {
    "path": "EnvTestCRC_RPG.ipynb",
    "chars": 1099036,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 15,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n"
  },
  {
    "path": "EnvTestFuturesNews_DRL.ipynb",
    "chars": 1321210,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n "
  },
  {
    "path": "EnvTestFuturesNews_RPG.ipynb",
    "chars": 1343745,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 7,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n "
  },
  {
    "path": "EnvTestStock_DRL.ipynb",
    "chars": 1659549,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 3,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n "
  },
  {
    "path": "EnvTestStock_RPG.ipynb",
    "chars": 1709723,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 114,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": ["
  },
  {
    "path": "README.md",
    "chars": 1938,
    "preview": "# Applying Reinforcement Learning in Quantitative Trading\n\n## Overview  \n\nThis is the repository of my graduate thesis w"
  },
  {
    "path": "agents/__init__.py",
    "chars": 22,
    "preview": "# -*- coding:utf-8 -*-"
  },
  {
    "path": "agents/agent.py",
    "chars": 370,
    "preview": "# -*- coding:utf-8 -*-\nfrom abc import abstractmethod\n\n\nclass Agent(object):\n    def __init__(self):\n        pass\n    \n "
  },
  {
    "path": "agents/drl_agent.py",
    "chars": 3814,
    "preview": "# -*- coding:utf-8 -*-\nfrom agents.agent import Agent\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimp"
  },
  {
    "path": "agents/drl_news_agent.py",
    "chars": 5616,
    "preview": "# -*- coding:utf-8 -*-\nfrom agents.agent import Agent\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimp"
  },
  {
    "path": "agents/rpg_agent.py",
    "chars": 4674,
    "preview": "# -*- coding:utf-8 -*-\nfrom agents.agent import Agent\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimp"
  },
  {
    "path": "agents/rpg_news_agent.py",
    "chars": 6306,
    "preview": "# -*- coding:utf-8 -*-\nfrom agents.agent import Agent\nimport torch\nimport torch.nn as nn\nimport torch.optim as optim\nimp"
  },
  {
    "path": "crypto_currency/DDPG.ipynb",
    "chars": 439059,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"#  DDPG Crypto-Currency Trading\"\n  "
  },
  {
    "path": "crypto_currency/DDRPG_shareV.ipynb",
    "chars": 428387,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"#  DDPG Crypto-Currency Trading\"\n  "
  },
  {
    "path": "crypto_currency/DQN.ipynb",
    "chars": 438669,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {},\n   \"outputs\": [\n    {\n     \"name\":"
  },
  {
    "path": "crypto_currency/DataUtils.py",
    "chars": 2753,
    "preview": "import pandas as pd\nimport numpy as np\nimport talib\nfrom .HuobiServices import *\ndef generate_tech_data(stock, open_name"
  },
  {
    "path": "crypto_currency/DirectRL.ipynb",
    "chars": 431771,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 1,\n   \"metadata\": {},\n   \"outputs\": [\n    {\n     \"name\":"
  },
  {
    "path": "crypto_currency/HuobiServices.py",
    "chars": 9286,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Date    : 2017-12-20 15:40:03\n# @Author  : KlausQiu\n# @QQ      : 375235"
  },
  {
    "path": "crypto_currency/PolicyGradient.ipynb",
    "chars": 218656,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"# Policy Gradient Crypto-Currency T"
  },
  {
    "path": "crypto_currency/PortfolioSelection.ipynb",
    "chars": 183859,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 61,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n"
  },
  {
    "path": "crypto_currency/RecurrentPG.ipynb",
    "chars": 678666,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"#  Recurrent PG Crypto-Currency Tra"
  },
  {
    "path": "crypto_currency/RecurrentPG_shareV.ipynb",
    "chars": 480456,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"markdown\",\n   \"metadata\": {},\n   \"source\": [\n    \"#  Recurrent PG Crypto-Currency Tra"
  },
  {
    "path": "crypto_currency/Utils.py",
    "chars": 3906,
    "preview": "#!/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Date    : 2017-12-20 15:40:03\n# @Author  : KlausQiu\n# @QQ      : 375235"
  },
  {
    "path": "env/__init__.py",
    "chars": 22,
    "preview": "# -*- coding:utf-8 -*-"
  },
  {
    "path": "env/crc_env.py",
    "chars": 9817,
    "preview": "# -*- coding:utf-8 -*-\nimport os\nimport pandas as pd\nimport talib\nimport numpy as np\nfrom collections import OrderedDict"
  },
  {
    "path": "env/futures_env.py",
    "chars": 9790,
    "preview": "# -*- coding:utf-8 -*-\nimport quandl\nimport pandas as pd\nimport talib\nimport numpy as np\nimport os\n\n\nclass FuturesEnv(ob"
  },
  {
    "path": "env/stock_env.py",
    "chars": 10177,
    "preview": "# -*- coding:utf-8 -*-\nimport quandl\nimport pandas as pd\nimport talib\nimport numpy as np\nimport os\n\n\nclass StockEnv(obje"
  },
  {
    "path": "env/zipline_env.py",
    "chars": 9442,
    "preview": "# -*- coding:utf-8 -*-\nimport pandas as pd\nimport numpy as np\nimport zipline\nfrom zipline.api import record, symbol, ord"
  },
  {
    "path": "history/DRL_PairsTrading.py",
    "chars": 7435,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\n\n# This model_archive was inspired by\n# Deep"
  },
  {
    "path": "history/DRL_Portfolio.py",
    "chars": 7871,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\n\n# This model_archive was inspired by\n# Deep"
  },
  {
    "path": "history/DRL_Portfolio_Alpha.py",
    "chars": 7875,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\n\n# This model_archive was inspired by\n# Deep"
  },
  {
    "path": "history/DRL_Portfolio_Isolated.py",
    "chars": 9478,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "history/DRL_Portfolio_Isolated_Simple.py",
    "chars": 13215,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "history/PairsTradingBacktest.py",
    "chars": 5518,
    "preview": "# -*- coding:utf-8 -*-\nimport sys\n\nimport logbook\nimport numpy as np\nimport pandas as pd\nimport talib\nimport zipline\nfro"
  },
  {
    "path": "history/PairsTradingTutorial.ipynb",
    "chars": 256051,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 30,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": [\n"
  },
  {
    "path": "history/PortfolioBacktest.py",
    "chars": 9595,
    "preview": "# -*- coding:utf-8 -*-\nimport itertools\nimport os\nimport sys\n\nimport logbook\nimport numpy as np\nimport pandas as pd\nimpo"
  },
  {
    "path": "history/PortfolioBacktestAlpha.py",
    "chars": 10500,
    "preview": "# -*- coding:utf-8 -*-\nimport itertools\nimport os\nimport sys\n\nimport logbook\nimport numpy as np\nimport pandas as pd\nimpo"
  },
  {
    "path": "history/PortfolioBacktestIsoloated.py",
    "chars": 17779,
    "preview": "# -*- coding:utf-8 -*-\nimport pandas as pd\nimport zipline\nimport quandl\nfrom DRL_Portfolio_EIIE_simple import DRL_Portfo"
  },
  {
    "path": "history/PortfolioBacktestNews.py",
    "chars": 9958,
    "preview": "# -*- coding:utf-8 -*-\nimport itertools\nimport os\nimport sys\n\nimport logbook\nimport numpy as np\nimport pandas as pd\nimpo"
  },
  {
    "path": "history/PortfolioBacktestNewsAlpha.py",
    "chars": 9608,
    "preview": "# -*- coding:utf-8 -*-\nimport itertools\nimport os\nimport sys\n\nimport logbook\nimport numpy as np\nimport pandas as pd\nimpo"
  },
  {
    "path": "history/PortfolioTutorial.ipynb",
    "chars": 742386,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 2,\n   \"metadata\": {},\n   \"outputs\": [\n    {\n     \"name\":"
  },
  {
    "path": "history/Tutorial.ipynb",
    "chars": 742386,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 2,\n   \"metadata\": {},\n   \"outputs\": [\n    {\n     \"name\":"
  },
  {
    "path": "history/ZiplineTensorboard.py",
    "chars": 3789,
    "preview": "import datetime\nimport tensorflow as tf\nimport numpy as np\n\n\"\"\"\nThis code was from: https://github.com/jimgoo/zipline-te"
  },
  {
    "path": "model_archive/DRL_Portfolio_Highway.py",
    "chars": 13867,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/DRL_Portfolio_Isolated.py",
    "chars": 9478,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/DRL_Portfolio_Isolated_Hedge.py",
    "chars": 14419,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/DRL_Portfolio_Isolated_Simple.py",
    "chars": 14078,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/DRL_Portfolio_Simple.py",
    "chars": 13519,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/DRL_Portfolio_Whatever.py",
    "chars": 14725,
    "preview": "# -*- coding:utf-8 -*-\nimport tensorflow as tf\nimport numpy as np\nimport os\nimport tflearn as tl\n\n# This model_archive w"
  },
  {
    "path": "model_archive/HedgeFundTradingExample.py",
    "chars": 5734,
    "preview": "# -*- coding:utf-8 -*-\nimport re\nimport tensorflow as tf\n\nimport requests\nimport itertools\n\nfrom zipline.data import bun"
  },
  {
    "path": "model_archive/HyperParameterTuning.py",
    "chars": 7375,
    "preview": "# -*- coding:utf-8 -*-\nimport os\nimport requests\nimport itertools\nfrom utils.EnvironmentUtils import build_backtest_envi"
  },
  {
    "path": "model_archive/ResultAnalysis.ipynb",
    "chars": 4314910,
    "preview": "{\n \"cells\": [\n  {\n   \"cell_type\": \"code\",\n   \"execution_count\": 168,\n   \"metadata\": {},\n   \"outputs\": [],\n   \"source\": ["
  },
  {
    "path": "model_archive/SimpleModel.py",
    "chars": 23,
    "preview": "# -*- coding:utf-8 -*-\n"
  },
  {
    "path": "model_archive/TradingExample.py",
    "chars": 7798,
    "preview": "# -*- coding:utf-8 -*-\nimport re\nimport tensorflow as tf\n\nimport requests\nimport itertools\n\nfrom zipline.data import bun"
  },
  {
    "path": "model_archive/__init__.py",
    "chars": 22,
    "preview": "# -*- coding:utf-8 -*-"
  },
  {
    "path": "utils/DataUtils.py",
    "chars": 10160,
    "preview": "# -*- coding:utf-8 -*-\nimport talib\nimport pandas as pd\nimport os\nimport numpy as np\n\nimport quandl\n\nquandl.ApiConfig.ap"
  },
  {
    "path": "utils/EnvironmentUtils.py",
    "chars": 1502,
    "preview": "# -*- coding:utf-8 -*-\nimport os\n\nfrom zipline.data import bundles\nfrom zipline.utils.calendars import get_calendar\nfrom"
  },
  {
    "path": "utils/HuobiServices.py",
    "chars": 9397,
    "preview": "# !/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Date    : 2017-12-20 15:40:03\n# @Author  : KlausQiu\n# @QQ      : 37523"
  },
  {
    "path": "utils/SysUtils.py",
    "chars": 3842,
    "preview": "# !/usr/bin/env python\n# -*- coding: utf-8 -*-\n# @Date    : 2017-12-20 15:40:03\n# @Author  : KlausQiu\n# @QQ      : 37523"
  },
  {
    "path": "utils/ZiplineTensorboard.py",
    "chars": 4039,
    "preview": "import datetime\nimport tensorflow as tf\nimport numpy as np\n\n\"\"\"\nThis code was from: https://github.com/jimgoo/zipline-te"
  },
  {
    "path": "utils/__init__.py",
    "chars": 22,
    "preview": "# -*- coding:utf-8 -*-"
  }
]

About this extraction

This page contains the full source code of the yuriak/RLQuant GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 62 files (16.8 MB), approximately 4.4M tokens, and a symbol index with 397 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!