rebalancing weights daily.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:08:16.329526Z",
     "start_time": "2018-10-15T01:08:13.986966Z"
    }
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import numpy as np\n",
    "from numpy import cumsum, log, polyfit, sqrt, std, subtract\n",
    "from numpy.random import randn\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "import statsmodels.tsa.stattools as ts          \n",
    "from statsmodels.graphics.tsaplots import plot_acf\n",
    "from johansen import Johansen\n",
    "import itertools\n",
    "\n",
    "import datetime as dt\n",
    "\n",
    "#%matplotlib inline\n",
    "plt.style.use('ggplot')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "min_perday=1380"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.chdir('C:\\\\Users\\\\lin\\\\OneDrive\\\\practium\\\\23_hour')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:08:16.763304Z",
     "start_time": "2018-10-15T01:08:16.369719Z"
    }
   },
   "outputs": [],
   "source": [
    "#               UTB,       TB,        U10y,      10y,       5y,        2y\n",
    "bonds =        ['UB',      'ZB',      'TN',       'ZN',     'ZF',      'ZT']\n",
    "tick_sizes =   [0.03125,   0.03125,   0.015625,   0.015625, 0.0078125, 0.0078125]\n",
    "point_values = [1000,      1000,      1000,       1000,     1000,      2000]\n",
    "maturities = ['8U']\n",
    "maturities_ss = ['U8'] # strategy_studio convention\n",
    "file_suffix = '.pik'\n",
    "series_suffix = '_mid'\n",
    "contract_srt = '2018-06-01'\n",
    "contract_end = '2018-09-01'\n",
    "\n",
    "#dont forget set up file path lul\n",
    "\n",
    "\n",
    "#data_path = '../Data/'+str(mins_per_day)+'/'\n",
    "#data_path = '../Data/'\n",
    "\n",
    "assets = [''.join(x) for x in itertools.product(bonds,maturities)]\n",
    "\n",
    "dfs = []\n",
    "for a in assets:\n",
    "    dfs.append(pd.read_pickle(a+file_suffix)[a+series_suffix])\n",
    "df = pd.concat(dfs, axis=1)\n",
    "\n",
    "# match different periods\n",
    "df = df.dropna()\n",
    "    \n",
    "# ignore the first and last few days\n",
    "#df = df.iloc[390*start_ignore:-390*end_engore]\n",
    "    \n",
    "# ignore the beginning and end of contract\n",
    "df['shifted_trading_time'] = df.index.tz_convert('Etc/GMT-2')\n",
    "df = df[(df['shifted_trading_time'] >= contract_srt) & (df['shifted_trading_time'] < contract_end)]\n",
    "\n",
    "# drop weekends\n",
    "df = df.loc[df['shifted_trading_time'].dt.weekday<5]   \n",
    "df = df.drop('shifted_trading_time',axis=1)\n",
    "\n",
    "#** for strategy studio\n",
    "assets = [''.join(x) for x in itertools.product(bonds,maturities_ss)]\n",
    "\n",
    "# name columns\n",
    "df.columns = assets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "#deal with data issue\n",
    "df.loc['2018-08-29 17:00:00']['UBU8'] = 158.671875\n",
    "df.loc['2018-08-29 17:00:00']['ZFU8'] = 113.394531"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:08:17.594643Z",
     "start_time": "2018-10-15T01:08:17.528152Z"
    }
   },
   "outputs": [],
   "source": [
    "train_template = df.copy()\n",
    "#if len(train_template.loc[train_template.iloc[-1].name.date():]) < min_perday:        # if the last day is not complete\n",
    "#    last_index = dt.datetime.combine(train_template.iloc[-1].name.date(),dt.time(0,0))-dt.timedelta(minutes=1)\n",
    "#    train_template = train_template.loc[:last_index]  # take data until the last day   \n",
    "#if len(train_template.loc[:train_template.iloc[min_perday].name.date()]) < min_perday:       # if the first day is not complete\n",
    "#    train_template = train_template.loc[train_template.iloc[min_perday].name.date():] # take data from the next day\n",
    "#train_template.columns = assets\n",
    "#train_template = train_template.iloc[min_perday*14:-min_perday*14]  # ignore the first and last two weeks\n",
    "train_template = train_template*point_values\n",
    "weights = train_template.columns+'_weight'\n",
    "for w in weights:\n",
    "    train_template[w] = np.nan\n",
    "train_template['trading_idx'] = np.nan\n",
    "train_template['portfolio'] = np.nan\n",
    "train_template['mu'] = np.nan\n",
    "train_template['sigma'] = np.nan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:08:30.275862Z",
     "start_time": "2018-10-15T01:08:30.267572Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "66.0"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(train_template)/min_perday"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Parameter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:10:05.184250Z",
     "start_time": "2018-10-15T01:10:05.178530Z"
    }
   },
   "outputs": [],
   "source": [
    "#change our value here!\n",
    "use_optimized_parameters = True\n",
    "op_fitting_days = 20\n",
    "op_exit_threshold = 0\n",
    "op_increment = 1.75\n",
    "op_trading_days = 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:10:06.107628Z",
     "start_time": "2018-10-15T01:10:05.890842Z"
    }
   },
   "outputs": [],
   "source": [
    "#leave this part fixed\n",
    "def fit(data):\n",
    "    x = data.values\n",
    "    x_centered = x - np.mean(x, axis=0)\n",
    "    johansen = Johansen(x_centered, model=2, significance_level=0)\n",
    "    eigenvectors, r = johansen.johansen()\n",
    "    #print('rejected r values are: {}'.format(r))\n",
    "    vec = eigenvectors[:, 0]\n",
    "    vec_min = np.min(np.abs(vec))\n",
    "    vec = vec / vec_min\n",
    "    #print('The first cointegrating relation: {}'.format(vec))\n",
    "    return vec    \n",
    "\n",
    "\n",
    "def apply_strategy(train):\n",
    "    \n",
    "    # get thresholds\n",
    "    round_trip_cost = (np.array(tick_sizes)*np.array(point_values)*abs(train[weights])).sum(axis=1)\n",
    "    min_increment = round_trip_cost/train['sigma']\n",
    "    entry_threshold = exit_threshold+min_increment+increment\n",
    "    train['entry_threshold'] = entry_threshold\n",
    "    \n",
    "    train['position'] = np.nan\n",
    "    train['l_position'] = np.nan\n",
    "    train['s_position'] = np.nan\n",
    "\n",
    "    # record position changes\n",
    "    train['s_position'].loc[train['portfolio'] > (train['mu'] + entry_threshold*train['sigma'])] = -1\n",
    "    train['s_position'].loc[train['portfolio'] < (train['mu'] + exit_threshold*train['sigma'])] = 0\n",
    "\n",
    "    train['l_position'].loc[train['portfolio'] < (train['mu'] - entry_threshold*train['sigma'])] = 1\n",
    "    train['l_position'].loc[train['portfolio'] > (train['mu'] - exit_threshold*train['sigma'])] = 0\n",
    "\n",
    "\n",
    "    # portfolio is flat at beginning of test period\n",
    "    train['s_position'].iloc[0] = 0\n",
    "    train['l_position'].iloc[0] = 0\n",
    "    # flatten portfolio at end of each trading period\n",
    "    #train['s_position'].loc[train.trading_idx.diff(-1) != 0] = 0\n",
    "    #train['l_position'].loc[train.trading_idx.diff(-1) != 0] = 0\n",
    "    # flatten portfolio at end\n",
    "    train['s_position'].iloc[-1] = 0\n",
    "    train['l_position'].iloc[-1] = 0\n",
    "    # forward fill positions\n",
    "    train['s_position'] = train['s_position'].ffill()\n",
    "    train['l_position'] = train['l_position'].ffill()\n",
    "\n",
    "    # sum positions\n",
    "    train['position'] = train['l_position'] + train['s_position']\n",
    "\n",
    "    # extract trades\n",
    "    train['trade'] = train['position'].diff(1)\n",
    "    \n",
    "    return train\n",
    "\n",
    "\n",
    "def calc_pnl(round_trips):\n",
    "    pnls = round_trips[assets]\n",
    "    # adjust price changes for trade signal\n",
    "    pnls = pnls.multiply(np.sign(round_trips[weights].values), axis=0)\n",
    "    pnls = pnls.multiply(-np.sign(round_trips['position'].values), axis=0)\n",
    "    # account for crossing the spread\n",
    "    pnls = pnls - np.array(tick_sizes)*np.array(point_values)\n",
    "    # apply contract weights\n",
    "    pnls = pnls * np.abs(round_trips[weights].values)\n",
    "    return pnls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## my change is located here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rebalance parameters\n",
    "assets_point=[]\n",
    "for i in assets:\n",
    "    assets_point.append(i+'_point')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "def getrebalance(train):\n",
    "    #this function generates the \n",
    "    train['isrebalance_temp']=np.zeros(len(train))\n",
    "    #past code of force closing from zehua\n",
    "    train['isrebalance_temp'].loc[train.trading_idx.diff(-1) != 0]=1 # get the last min of a trading period\n",
    "    #train['isrebalance_temp'].loc[train.trading_idx.diff(1) != 0]=1 # get the first min of each trading period\n",
    "    #rebalance only if the position is not 0 here\n",
    "    #we use abs in case of -1 position\n",
    "    train['isrebalance']=np.abs(train['position'].values*train['isrebalance_temp'].values)\n",
    "    #assets_point are just notation, defined above\n",
    "    for i in range(6):\n",
    "        train[assets_point[i]]=train[assets[i]].values*train[weights[i]].values\n",
    "    #we use this code because there is absolutely no two isrebalance in a row, as trading period is at least one day\n",
    "    #but our training session (I mean price gap) is minute by minute\n",
    "    train['rebalance']=train['isrebalance'].diff(1)\n",
    "    return train\n",
    "\n",
    "def rebalance_cost(rebalance):\n",
    "    #calculate the cost and record rebalance case\n",
    "    #return a dataframe\n",
    "    #we could cut off rebalance cost independently, as in the case of rebalance, there must no transcation recorded at 'positioin'\n",
    "    \n",
    "    rebalance_round= rebalance.iloc[1::2].reset_index() - rebalance.iloc[::2].reset_index()\n",
    "    rebalance_round[weights] = rebalance[weights].iloc[1::2].reset_index(drop=True)\n",
    "    rebalance_round=rebalance_round.dropna()\n",
    "    rebalance_round=rebalance_round.loc[np.abs(rebalance_round[weights].values).sum(axis=1)<600]\n",
    "    #here, we only consider the case that position remains equal and position !=0 for before and after trading index\n",
    "    \n",
    "    rebalance_round=rebalance_round.loc[rebalance_round['position']==0]\n",
    "    pnl_rebalance=rebalance_round[assets_point]\n",
    "    #pnl_rebalance = pnl_rebalance.multiply(np.sign(rebalance_round[weights].values), axis=0)\n",
    "    #pnl_rebalance = pnl_rebalance.multiply(-rebalance_round['position'].values, axis=0)\n",
    "    # account for crossing the spread\n",
    "    pnl_rebalance = pnl_rebalance - (rebalance_round[weights].values)*np.array(tick_sizes)*np.array(point_values)\n",
    "    # apply contract weights\n",
    "    #pnl_rebalance = pnl_rebalance * np.abs(rebalance_round[weights].values)\n",
    "    return pnl_rebalance\n",
    "    \n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "#test\n",
    "rebalance_round= rebalance_form.iloc[1::2].reset_index() - rebalance_form.iloc[::2].reset_index()"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "rebalance_round\n",
    "pnl_rebalance=rebalance_round[assets_point]\n",
    "#pnl_rebalance = pnl_rebalance - np.array(tick_sizes)*np.array(point_values)*(rebalance_round[weights].values)\n",
    "#pnl_rebalance = pnl_rebalance.multiply(np.sign(rebalance_round[weights].values), axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "#np.array(tick_sizes)*np.array(point_values)*(rebalance_round[weights].values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pnl_rebalance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## I got no idea here, it seems that the time choosing term got a little bit problem?\n",
    "## there shall be a little bug, plz check it if you figure out\n",
    "## It seems that I figure it out? (02.15 am)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rebalance_round[weights]\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:12:32.646751Z",
     "start_time": "2018-10-15T01:12:32.632568Z"
    }
   },
   "outputs": [],
   "source": [
    "# set parameters:\n",
    "if use_optimized_parameters:\n",
    "    fitting_days_range = [op_fitting_days]\n",
    "    exit_threshold_range = [op_exit_threshold]\n",
    "    increment_range = [op_increment]\n",
    "else:\n",
    "    fitting_days_range = range(5,25,5)\n",
    "    exit_threshold_range = np.arange(0,1,0.25)\n",
    "    increment_range = np.arange(0,4,0.25)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "#set(train['trading_idx'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A little bit change here, ask me if interested\n",
    "## I hope no bug this time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:12:33.807689Z",
     "start_time": "2018-10-15T01:12:33.414676Z"
    }
   },
   "outputs": [],
   "source": [
    "pnlrecord=[]#record PnL\n",
    "parameters=[]\n",
    "stop_sign=500 # value for stop trading if the 1 dim norm of weights too large, larger than stop_sign\n",
    "for fitting_days in fitting_days_range:\n",
    "    if use_optimized_parameters:\n",
    "        trading_days_range = [op_trading_days]\n",
    "    else:\n",
    "        trading_days_range = range(1,fitting_days)\n",
    "        \n",
    "    for trading_days in trading_days_range:\n",
    "        train = train_template.copy()\n",
    "    \n",
    "        trade_period = min_perday*trading_days\n",
    "        fit_period = min_perday*fitting_days\n",
    "        padding = min_perday*fitting_days\n",
    "        num_periods = (len(train)-padding)//trade_period\n",
    "        \n",
    "    \n",
    "        # training\n",
    "        for i in range(num_periods):\n",
    "            trading_start =  (padding + i     * trade_period)\n",
    "            trading_end =    (padding + (i+1) * trade_period)\n",
    "            fitting_start = trading_start-fit_period\n",
    "            fitting_end =   trading_start\n",
    "        \n",
    "            train['trading_idx'].iloc[trading_start:trading_end] = i\n",
    "            fit_data = train.iloc[fitting_start:fitting_end]\n",
    "            \n",
    "            coint_vec = fit(fit_data[assets])\n",
    "            fit_portfolio = np.dot(fit_data[assets].values, coint_vec)\n",
    "            #print(coint_vec)\n",
    "            \n",
    "            for j in range(len(coint_vec)):\n",
    "                train[weights[j]][train.trading_idx == i] = coint_vec[j]\n",
    "            \n",
    "            train['mu'][train.trading_idx == i] = fit_portfolio.mean()\n",
    "            train['sigma'][train.trading_idx == i] = fit_portfolio.std()\n",
    "            train['portfolio'][train.trading_idx == i] = np.dot(train[train.trading_idx == i][assets].values, coint_vec)\n",
    "            \n",
    "        train.dropna(subset=['trading_idx'],inplace=True)\n",
    "        \n",
    "        # formulate and apply strategy\n",
    "        for exit_threshold in exit_threshold_range:\n",
    "            for increment in increment_range:    \n",
    "                \n",
    "                apply_strategy(train)\n",
    "                \n",
    "                # find trades\n",
    "                trades = train.loc[train['trade'] != 0].dropna(subset=['trade'])\n",
    "                trades.reset_index(inplace=True)\n",
    "                # seperate trades where holding positions jumped\n",
    "                trades = trades.loc[trades.index.repeat(abs(trades['trade']).astype(int))].reset_index(drop=False)\n",
    "                \n",
    "                #I changed this part, but not sure\n",
    "                #I am idiot\n",
    "                #if the sum of the abs value of weights(first order norm of weights) outperforms stop_sign, we drop this term \n",
    "                trades['temp_value']=np.abs(trades[weights].values).sum(axis=1)\n",
    "                #trades['position'].loc[trades['temp_value']>stop_sign]=0\n",
    "                trades=trades.loc[trades['temp_value']<stop_sign]\n",
    "                trades_temp=trades.copy()\n",
    "\n",
    "                # get round trips\n",
    "                round_trips = trades_temp.iloc[1::2].reset_index() - trades_temp.iloc[::2].reset_index()\n",
    "                round_trips[weights] = trades[weights].iloc[::2].reset_index(drop=True)\n",
    "                round_trips=round_trips.dropna()\n",
    "                #round_trips.drop([round_trips.loc[sum(np.abs(round_trips[weights].values))>stop_sign].index])\n",
    "                \n",
    "                pnls = calc_pnl(round_trips)\n",
    "                \n",
    "                parameters.append([fitting_days,trading_days,exit_threshold,increment,num_periods])\n",
    "                result=pnls.sum(axis=1).to_frame('pnl')\n",
    "                result['holding_period'] = round_trips['timestamp']\n",
    "                result['trading_total_pos'] = abs(round_trips[weights]).sum(axis=1)\n",
    "                result['trading_net_pos'] = round_trips[weights].sum(axis=1)\n",
    "                result['abnormal_close'] = ((trades_temp['position'] == 0) & ((trades_temp['trade']==1)&(trades_temp['portfolio'] - trades_temp['mu'] > trades_temp['sigma']*exit_threshold) | (trades_temp['trade']==-1)&(trades_temp['portfolio'] - trades_temp['mu'] < trades_temp['sigma']*exit_threshold))).iloc[1::2].reset_index(drop=True)\n",
    "                pnlrecord.append(result)\n",
    "                          "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## running for the rebalance here\n",
    "## A bug triggered which I am not sure how to figure it out\n",
    "## (or just coincidence?)\n",
    "## plz tell me if you found problem"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>UBU8_point</th>\n",
       "      <th>ZBU8_point</th>\n",
       "      <th>TNU8_point</th>\n",
       "      <th>ZNU8_point</th>\n",
       "      <th>ZFU8_point</th>\n",
       "      <th>ZTU8_point</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "Empty DataFrame\n",
       "Columns: [UBU8_point, ZBU8_point, TNU8_point, ZNU8_point, ZFU8_point, ZTU8_point]\n",
       "Index: []"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "getrebalance(train)\n",
    "rebalance_form=train.loc[train['rebalance']!=0].dropna(subset=['rebalance'])\n",
    "lullin=rebalance_cost(rebalance_form)\n",
    "lullin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>index</th>\n",
       "      <th>timestamp</th>\n",
       "      <th>UBU8</th>\n",
       "      <th>ZBU8</th>\n",
       "      <th>TNU8</th>\n",
       "      <th>ZNU8</th>\n",
       "      <th>ZFU8</th>\n",
       "      <th>ZTU8</th>\n",
       "      <th>UBU8_weight</th>\n",
       "      <th>ZBU8_weight</th>\n",
       "      <th>...</th>\n",
       "      <th>trading_idx</th>\n",
       "      <th>portfolio</th>\n",
       "      <th>mu</th>\n",
       "      <th>sigma</th>\n",
       "      <th>entry_threshold</th>\n",
       "      <th>position</th>\n",
       "      <th>l_position</th>\n",
       "      <th>s_position</th>\n",
       "      <th>trade</th>\n",
       "      <th>temp_value</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>2018-07-05 09:48:00-05:00</td>\n",
       "      <td>160359.375</td>\n",
       "      <td>145546.875</td>\n",
       "      <td>128414.0625</td>\n",
       "      <td>120320.3125</td>\n",
       "      <td>113605.46875</td>\n",
       "      <td>211757.8125</td>\n",
       "      <td>-1.000000</td>\n",
       "      <td>-1.546695</td>\n",
       "      <td>...</td>\n",
       "      <td>0.0</td>\n",
       "      <td>575009.686317</td>\n",
       "      <td>576449.507366</td>\n",
       "      <td>274.663897</td>\n",
       "      <td>5.093891</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>60.788844</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>6</td>\n",
       "      <td>2018-08-10 09:48:00-05:00</td>\n",
       "      <td>158109.375</td>\n",
       "      <td>144046.875</td>\n",
       "      <td>127929.6875</td>\n",
       "      <td>120148.4375</td>\n",
       "      <td>113566.40625</td>\n",
       "      <td>211648.4375</td>\n",
       "      <td>-1.943495</td>\n",
       "      <td>3.321928</td>\n",
       "      <td>...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>-87904.850966</td>\n",
       "      <td>-86990.818126</td>\n",
       "      <td>147.200981</td>\n",
       "      <td>5.687685</td>\n",
       "      <td>1.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.0</td>\n",
       "      <td>35.801116</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>7</td>\n",
       "      <td>2018-08-13 14:24:00-05:00</td>\n",
       "      <td>158078.125</td>\n",
       "      <td>144328.125</td>\n",
       "      <td>128054.6875</td>\n",
       "      <td>120242.1875</td>\n",
       "      <td>113628.90625</td>\n",
       "      <td>211648.4375</td>\n",
       "      <td>-1.943495</td>\n",
       "      <td>3.321928</td>\n",
       "      <td>...</td>\n",
       "      <td>2.0</td>\n",
       "      <td>-86987.230901</td>\n",
       "      <td>-86990.818126</td>\n",
       "      <td>147.200981</td>\n",
       "      <td>5.687685</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>-1.0</td>\n",
       "      <td>35.801116</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>3 rows × 24 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "   index                 timestamp        UBU8        ZBU8         TNU8  \\\n",
       "0      0 2018-07-05 09:48:00-05:00  160359.375  145546.875  128414.0625   \n",
       "6      6 2018-08-10 09:48:00-05:00  158109.375  144046.875  127929.6875   \n",
       "7      7 2018-08-13 14:24:00-05:00  158078.125  144328.125  128054.6875   \n",
       "\n",
       "          ZNU8          ZFU8         ZTU8  UBU8_weight  ZBU8_weight  \\\n",
       "0  120320.3125  113605.46875  211757.8125    -1.000000    -1.546695   \n",
       "6  120148.4375  113566.40625  211648.4375    -1.943495     3.321928   \n",
       "7  120242.1875  113628.90625  211648.4375    -1.943495     3.321928   \n",
       "\n",
       "      ...      trading_idx      portfolio             mu       sigma  \\\n",
       "0     ...              0.0  575009.686317  576449.507366  274.663897   \n",
       "6     ...              2.0  -87904.850966  -86990.818126  147.200981   \n",
       "7     ...              2.0  -86987.230901  -86990.818126  147.200981   \n",
       "\n",
       "   entry_threshold  position  l_position  s_position  trade  temp_value  \n",
       "0         5.093891       1.0         1.0         0.0    1.0   60.788844  \n",
       "6         5.687685       1.0         1.0         0.0    1.0   35.801116  \n",
       "7         5.687685       0.0         0.0         0.0   -1.0   35.801116  \n",
       "\n",
       "[3 rows x 24 columns]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "trades"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "timestamp\n",
       "2018-07-18 15:59:00-05:00    1.0\n",
       "2018-07-18 17:00:00-05:00    0.0\n",
       "Name: position, dtype: float64"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rebalance_form['position']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train.loc['2018-08-26 17:00:00-05:00']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rebalance_form[1::2]\n",
    "#round_temp=rebalance_form[1::2].reset_index()-rebalance_form[::2].reset_index()\n",
    "#round_temp.loc[round_temp['position']==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pnlaaa=rebalance_cost(rebalance_form)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "#pnlaaa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rebalance_form[weights]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "#assets_point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "#rebalanceaaaaa=rebalance_cost(rebalance_form)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "#train.iloc[1380]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:12:36.890998Z",
     "start_time": "2018-10-15T01:12:36.866055Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "          pnl holding_period  trading_total_pos  trading_net_pos  \\\n",
      "0 -918.446132        36 days          60.788844         2.290757   \n",
      "\n",
      "   abnormal_close  \n",
      "0           False  \n",
      "[20, 14, 0, 1.75, 3]\n",
      "[-21.86776505]\n"
     ]
    }
   ],
   "source": [
    "daily_profit=np.zeros([len(pnlrecord),1])               \n",
    "for i in range(len(pnlrecord)):\n",
    "    daily_profit[i]=pnlrecord[i]['pnl'].sum()/parameters[i][1]/parameters[i][4]\n",
    "maximum=np.max(daily_profit)\n",
    "idx=daily_profit.argmax()\n",
    "#[best_parameterfitting_days,trading_days,exit_threshold,op_increment,num_preiods]\n",
    "best_parameter=parameters[idx]\n",
    "print(pnlrecord[idx])\n",
    "print(best_parameter)\n",
    "print(max(daily_profit))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pnl</th>\n",
       "      <th>holding_period</th>\n",
       "      <th>trading_total_pos</th>\n",
       "      <th>trading_net_pos</th>\n",
       "      <th>abnormal_close</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>-918.446132</td>\n",
       "      <td>36 days</td>\n",
       "      <td>60.788844</td>\n",
       "      <td>2.290757</td>\n",
       "      <td>False</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          pnl holding_period  trading_total_pos  trading_net_pos  \\\n",
       "0 -918.446132        36 days          60.788844         2.290757   \n",
       "\n",
       "   abnormal_close  \n",
       "0           False  "
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "-21.86776504809534"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "display(pnlrecord[idx])\n",
    "daily_profit.sum()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## not sure value plot here"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-10-15T01:12:42.890781Z",
     "start_time": "2018-10-15T01:12:42.853926Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.legend.Legend at 0x266ac9a9be0>"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "adjusted_weights = train[weights].multiply(np.sign(train[weights].iloc[:,0].values),axis=0)\n",
    "weights_daily = adjusted_weights.iloc[::1380,]\n",
    "weights_daily.plot()\n",
    "plt.legend(loc='center left',bbox_to_anchor=(1,0.5))\n",
    "weights_daily.diff().plot()\n",
    "plt.legend(loc='center left',bbox_to_anchor=(1,0.5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-108.86585989512534\n",
      "313.13928363079225\n"
     ]
    }
   ],
   "source": [
    "iter_column = 5\n",
    "plt.hist(weights_daily.iloc[:,iter_column],bins=50)\n",
    "plt.show()\n",
    "print(weights_daily.iloc[:,iter_column].mean())\n",
    "print(weights_daily.iloc[:,iter_column].std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x266acfc2198>]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "s_t = min_perday*0\n",
    "e_t = min_perday*10\n",
    "train['portfolio'].iloc[s_t:e_t].plot()\n",
    "plt.plot((train.mu+train['entry_threshold']*train.sigma).iloc[s_t:e_t])\n",
    "plt.plot((train.mu).iloc[s_t:e_t])\n",
    "plt.plot((train.mu-train['entry_threshold']*train.sigma).iloc[s_t:e_t])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "#display(train)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'UBU8'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "assets[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DatetimeIndex(['2018-06-14 17:00:00-05:00', '2018-06-17 17:00:00-05:00',\n",
       "               '2018-06-18 17:00:00-05:00', '2018-06-19 17:00:00-05:00',\n",
       "               '2018-06-20 17:00:00-05:00', '2018-06-21 17:00:00-05:00',\n",
       "               '2018-06-24 17:00:00-05:00', '2018-06-25 17:00:00-05:00',\n",
       "               '2018-06-26 17:00:00-05:00', '2018-06-27 17:00:00-05:00',\n",
       "               '2018-06-28 17:00:00-05:00', '2018-07-01 17:00:00-05:00',\n",
       "               '2018-07-02 17:00:00-05:00', '2018-07-03 17:00:00-05:00',\n",
       "               '2018-07-04 17:00:00-05:00', '2018-07-05 17:00:00-05:00',\n",
       "               '2018-07-08 17:00:00-05:00', '2018-07-09 17:00:00-05:00',\n",
       "               '2018-07-10 17:00:00-05:00', '2018-07-11 17:00:00-05:00',\n",
       "               '2018-07-12 17:00:00-05:00', '2018-07-15 17:00:00-05:00',\n",
       "               '2018-07-16 17:00:00-05:00', '2018-07-17 17:00:00-05:00',\n",
       "               '2018-07-18 17:00:00-05:00', '2018-07-19 17:00:00-05:00',\n",
       "               '2018-07-22 17:00:00-05:00', '2018-07-23 17:00:00-05:00',\n",
       "               '2018-07-24 17:00:00-05:00', '2018-07-25 17:00:00-05:00',\n",
       "               '2018-07-26 17:00:00-05:00', '2018-07-29 17:00:00-05:00',\n",
       "               '2018-07-30 17:00:00-05:00', '2018-07-31 17:00:00-05:00',\n",
       "               '2018-08-01 17:00:00-05:00', '2018-08-02 17:00:00-05:00',\n",
       "               '2018-08-05 17:00:00-05:00', '2018-08-06 17:00:00-05:00',\n",
       "               '2018-08-07 17:00:00-05:00', '2018-08-08 17:00:00-05:00',\n",
       "               '2018-08-09 17:00:00-05:00', '2018-08-12 17:00:00-05:00',\n",
       "               '2018-08-13 17:00:00-05:00', '2018-08-14 17:00:00-05:00',\n",
       "               '2018-08-15 17:00:00-05:00', '2018-08-16 17:00:00-05:00',\n",
       "               '2018-08-19 17:00:00-05:00', '2018-08-20 17:00:00-05:00',\n",
       "               '2018-08-21 17:00:00-05:00', '2018-08-22 17:00:00-05:00',\n",
       "               '2018-08-23 17:00:00-05:00', '2018-08-26 17:00:00-05:00',\n",
       "               '2018-08-27 17:00:00-05:00', '2018-08-28 17:00:00-05:00',\n",
       "               '2018-08-29 17:00:00-05:00'],\n",
       "              dtype='datetime64[ns, US/Central]', name='timestamp', freq=None)"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train.index[0::1380]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### output the parameter txt\n",
    "### I've already added the term that whether or not abnormal close in term of True or False\n",
    "### if you requires 0/1, just add a format casting (I mean, int()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator_temp=0\n",
    "for row in train[::min_perday].iterrows():\n",
    "    #print(row[1].name.date()+dt.timedelta(days=1))\n",
    "    date = (row[1].name.date()+dt.timedelta(days=1))\n",
    "    print(date)\n",
    "    with open('{}.txt'.format(date),'w') as file:\n",
    "        file.write('signal_mean={}\\n'.format(row[1]['mu']))\n",
    "        file.write('signal_standard_deviation={}\\n'.format(row[1]['sigma']))\n",
    "        file.write('entry_threshold={}\\n'.format(row[1]['entry_threshold']))\n",
    "        file.write('exit_threshold={}\\n'.format(op_exit_threshold))\n",
    "        file.write('abnormal_close={}\\n'.format(int(iterator_temp%op_trading_days==0)))\n",
    "        iterator_temp+=1\n",
    "        #row_weights = row[1][weights]\n",
    "        #for i in range(len(row_weights)):\n",
    "         #   file.write('{}={}\\n'.format(assets[i],row_weights[i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(Timestamp('2018-08-29 17:00:00-0500', tz='US/Central'),\n",
       " UBU8               1.586719e+05\n",
       " ZBU8               1.445625e+05\n",
       " TNU8               1.279766e+05\n",
       " ZNU8               1.200781e+05\n",
       " ZFU8               1.133945e+05\n",
       " ZTU8               2.114297e+05\n",
       " UBU8_weight        7.305390e+00\n",
       " ZBU8_weight        3.528690e+02\n",
       " TNU8_weight        1.000000e+00\n",
       " ZNU8_weight       -2.521468e+03\n",
       " ZFU8_weight        3.499663e+03\n",
       " ZTU8_weight       -1.027203e+03\n",
       " trading_idx        1.000000e+01\n",
       " portfolio         -7.081311e+07\n",
       " mu                -7.076373e+07\n",
       " sigma              2.265986e+04\n",
       " entry_threshold    5.650961e+00\n",
       " position           0.000000e+00\n",
       " l_position         0.000000e+00\n",
       " s_position         0.000000e+00\n",
       " trade              0.000000e+00\n",
       " Name: 2018-08-29 17:00:00-05:00, dtype: float64)"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "row"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.5"
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}