py-as-zhong/backtest.py

'''
    基于深度信息的异步事件触发回测框架
    作者 千千量化
'''
import strategy as strategy
import utils
import model
import time
import random

def timeit(func):
    def wrapper(*args, **kwargs):
        nowTime = time.time()
        func(*args, **kwargs)
        spend_time = time.time() - nowTime
        spend_time = round(spend_time * 100, 5)
        print(f'{func.__name__} 耗时 {spend_time} ms')

    return wrapper

class Backtest:
    '''
        回测框架
    '''

    def __init__(self, strategy:strategy.Strategy, data=None, is_plot=0):
        '''
            初始化实盘类
        '''
        # 获取策略对象
        self.strategy = strategy
        # 历史数据
        self.data = data
        # 交易品种
        self.symbol = 'backtest_symbol'
        # 虚拟挂单
        self.localOrders = dict()
        # 虚拟仓位
        self.pos = model.Position()
        # 中间价
        self.mp = None
        # 行情数据
        self.reference_price = []
        self.last_marketdata = []
        # 费率 maker taker
        self.fee = model.BacktestFee("v9")
        # 是否画图
        self._is_plot = is_plot
        self.long_hold = []
        self.short_hold = []
        self.index = []
        # 虚拟成交信息
        self.trade_num = 0
        # 记录持仓时间
        self.kd_time = None
        self.kk_time = None
        self.hold_times = [0.0]
        # 权益
        self.start_cash = 1000000.0
        self.equity = self.start_cash
        self.equity_real = self.start_cash
        self.equity_high = self.start_cash
        self.balance = [self.start_cash]
        self.strategy.start_cash = self.start_cash
        self.strategy.local_start_time = 0.0
        # 成交时间轴
        self.priceMotion = []
        self.kd_trade = []
        self.kk_trade = []
        self.pd_trade = []
        self.pk_trade = []
        # 挂单时间轴
        self.localOrders_timeseries = []
        # min max fill
        self.fill_price = []
        # 上次信号
        self.signal_series = dict()
        # 回测延迟 默认值
        self.backtest_delay = utils.BACKTEST_DELAY
        # 回测时间
        self.backtest_time = time.time()
        # 平均持仓时间
        self.avg_hold_time = 0.0
        # 最近一次处理的信号时间戳
        self.last_signal_time = 0.0
        
    def get_available_close_amt(self):
        a_pd, a_pk = self.pos.longPos, self.pos.shortPos
        for i in self.localOrders:
            if self.localOrders[i]["side"] == 'pd':
                a_pd -= self.localOrders[i]["amount"]
            if self.localOrders[i]["side"] == 'pk':
                a_pk -= self.localOrders[i]["amount"]
        return a_pd, a_pk

    # @timeit
    # 处理策略信号
    def handle_signal(self, signals):
        '''
            当信号>1tick 且时间超过n ms 才允许进行处理
        '''
        keys = list(signals.keys())
        for signal_time in keys:
            # 只允许处理上一tick时间戳之前的信号
            if signal_time < self.last_signal_time:
                pass
            else:
                continue
            if self.backtest_time - signal_time >= self.backtest_delay:
                signal = signals[signal_time]
                if signal == None:
                    return
                for i in signal:
                    # 撤销虚拟订单
                    if 'Cancel' in i:
                        if signal[i][0] in self.localOrders:
                            del(self.localOrders[signal[i][0]])
                    # 执行虚拟下单
                    elif 'Limits_open' in i:
                        for j in signal[i]:
                            order_event = dict()
                            order_event['symbol'] = self.symbol
                            order_event['status'] = "NEW"
                            order_event['amount'] = float(j[0])
                            order_event['side'] = j[1]
                            order_event['price'] = float(j[2])
                            order_event['filled_price'] = 0
                            order_event['filled'] = 0
                            order_event['client_id'] = str(random.randint(1,99999))
                            order_event['order_id'] = str(random.randint(1,99999))
                            order_event['localtime'] = signal_time
                            order_event['createtime'] = signal_time
                            self.localOrders[order_event['client_id']] = order_event
                    elif 'Limits_close' in i:
                        a_pd, a_pk = self.get_available_close_amt()
                        for j in signal[i]:
                            if j[1]  == "pd":
                                if j[0] > a_pd:
                                    break
                            elif j[1]  == "pk":
                                if j[0] > a_pk:
                                    break
                            order_event = dict()
                            order_event['symbol'] = self.symbol
                            order_event['status'] = "NEW"
                            order_event['amount'] = float(j[0])
                            order_event['side'] = j[1]
                            order_event['price'] = float(j[2])
                            order_event['filled_price'] = 0
                            order_event['filled'] = 0
                            order_event['client_id'] = str(random.randint(1,99999))
                            order_event['order_id'] = str(random.randint(1,99999))
                            order_event['localtime'] = signal_time
                            order_event['createtime'] = signal_time
                            self.localOrders[order_event['client_id']] = order_event
                del(signals[signal_time])
    
    # @timeit
    def matching(self, data):
        max_fill = 0 if data[utils.MAX_FILL_INDEX] == 0 else data[utils.MAX_FILL_INDEX]            # 最高成交价
        min_fill = 9999999999 if data[utils.MIN_FILL_INDEX] == 0 else data[utils.MIN_FILL_INDEX]  # 最低成交价
        # 本tick产生的pnl
        pnl = 0.0
        # 保存成交时间轴信息
        if self._is_plot:
            self.kd_trade.append(0)
            self.kk_trade.append(0)
            self.pd_trade.append(0)
            self.pk_trade.append(0)
        # 检查订单是否符合撮合条件
        max_kd = 0
        max_pk = 0
        min_kk = 9999999999
        min_pd = 9999999999
        # 本ticker
        now_bp = data[utils.BP_INDEX]
        now_ap = data[utils.AP_INDEX]
        self.mp = (now_ap + now_bp)*0.5
        match_bp = now_bp
        match_ap = now_ap
        if self.last_marketdata != []:
            # 前ticker
            bp = self.last_marketdata[utils.BP_INDEX]
            ap = self.last_marketdata[utils.AP_INDEX]
            localOrdersCid = list(self.localOrders)
            # 初始化成交标记
            filled_flag = 0
            filled_fee = 0.0
            filled_price = 0.0
            # 检查所有挂单是否被成交
            for cid in localOrdersCid:
                # 为每个订单重置成交标记
                filled_flag = 0
                filled_fee = 0.0
                filled_price = 0.0
                # 获取订单
                i = self.localOrders[cid]
                # 买单
                if i["side"] == "kd":
                    if self._is_plot: max_kd = max(max_kd,i['price'])
                    # 判断吃单成交还是挂单成交
                    if i['price'] > ap: # 吃单成交
                        filled_flag = 1
                        filled_fee = self.fee.taker
                        filled_price = ap
                    elif i["price"] > match_ap: # 挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    elif i["price"] > min_fill: # 一定概率被挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    if filled_flag:
                        del(self.localOrders[cid])
                        self.trade_num += 1
                        value = i['amount'] * filled_price
                        self.pos.longAvg = (self.pos.longPos * self.pos.longAvg + value)/(self.pos.longPos + i['amount'])
                        self.pos.longPos += i['amount']
                        pnl -= filled_fee * value
                        self.kd_time = self.strategy.local_time
                        if self._is_plot:
                            self.kd_trade[-1] = filled_price
                elif i["side"] == "pk":
                    if self._is_plot: max_pk = max(max_pk,i['price'])
                    # 判断吃单成交还是挂单成交
                    if i["price"] > ap: # 吃单成交
                        filled_flag = 1
                        filled_fee = self.fee.taker
                        filled_price = ap
                    elif i["price"] > match_ap: # 挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    elif i["price"] > min_fill: # 一定概率被挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    if filled_flag:
                        del(self.localOrders[cid])
                        self.trade_num += 1
                        pct = (self.pos.shortAvg - filled_price)/self.pos.shortAvg
                        value = i['amount'] * filled_price
                        pnl += pct * value - filled_fee * value
                        self.pos.shortPos -= i['amount']
                        if self._is_plot:
                            self.pk_trade[-1] = filled_price
                            self.hold_times.append(self.strategy.local_time - self.kk_time)
                        else:
                            if self.avg_hold_time == 0.0:
                                self.avg_hold_time = self.strategy.local_time - self.kk_time
                            else:
                                self.avg_hold_time = self.avg_hold_time * 0.9 + (self.strategy.local_time - self.kk_time) * 0.1
                # 卖单
                elif i["side"] == "kk":
                    if self._is_plot: min_kk = min(min_kk,i['price'])
                    # 判断吃单成交还是挂单成交
                    if i["price"] < bp: # 吃单成交
                        filled_flag = 1
                        filled_fee = self.fee.taker
                        filled_price = i["price"]
                    elif i["price"] < match_bp: # 挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    elif i["price"] < max_fill: # 一定概率挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    if filled_flag:
                        del(self.localOrders[cid])
                        self.trade_num += 1
                        value = filled_price * i['amount']
                        self.pos.shortAvg = (self.pos.shortAvg*self.pos.shortPos + value)/(self.pos.shortPos + i['amount'])
                        self.pos.shortPos += i['amount']
                        pnl -= filled_fee * value
                        self.kk_time = self.strategy.local_time
                        if self._is_plot:
                            self.kk_trade[-1] = filled_price
                elif i["side"] == "pd":
                    if self._is_plot: min_pd = min(min_pd,i['price'])
                    # 判断吃单成交还是挂单成交
                    if i["price"] < bp: # 吃单成交
                        filled_flag = 1
                        filled_fee = self.fee.taker
                        filled_price = i["price"]
                    elif i["price"] < match_bp: # 挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    elif i["price"] < max_fill: # 一定概率挂单成交
                        filled_flag = 1
                        filled_fee = self.fee.maker
                        filled_price = i["price"]
                    if filled_flag:
                        del(self.localOrders[cid])
                        self.trade_num += 1
                        pct = (filled_price - self.pos.longAvg)/self.pos.longAvg
                        value = i['amount'] * i['price']
                        pnl += pct * value - filled_fee * value
                        self.pos.longPos -= i['amount']
                        if self._is_plot:
                            self.pd_trade[-1] = filled_price
                            self.hold_times.append(self.strategy.local_time - self.kd_time)
                        else:
                            if self.avg_hold_time == 0.0:
                                self.avg_hold_time = self.strategy.local_time - self.kd_time
                            else:
                                self.avg_hold_time = self.avg_hold_time * 0.9 + (self.strategy.local_time - self.kd_time) * 0.1
            # 当前浮动盈亏
            unrealized_pnl = 0 
            if self.pos.longPos > 0:
                unrealized_pnl += (self.mp - self.pos.longAvg)/self.pos.longAvg * self.pos.longPos * self.mp
            if self.pos.shortPos > 0:
                unrealized_pnl += (self.pos.shortAvg - self.mp)/self.pos.shortAvg * self.pos.shortPos * self.mp
            # 如果需要画图
            if self._is_plot:
                # 保存挂单信息时间轴
                max_kd = 0 if max_kd == 0 else max_kd
                max_pk = 0 if max_pk == 0 else max_pk
                min_kk = 0 if min_kk == 9999999999 else min_kk
                min_pd = 0 if min_pd == 9999999999 else min_pd
                self.localOrders_timeseries.append([max_kd,max_pk,min_kk,min_pd])
                self.priceMotion.append(self.strategy.mp)
                # 参考价格
                self.reference_price.append(self.strategy.ref_price)
                # 成交情况
                self.fill_price.append([max_fill,min_fill])
                # 持仓情况
                self.long_hold.append(self.pos.longPos)
                self.short_hold.append(self.pos.shortPos)
                # 净值
                self.index.append(self.strategy.equity)
                # 记录浮动净值
                self.balance.append(self.equity + pnl + unrealized_pnl)
            # 记录净值 包含未实现盈亏
            self.equity_real = self.equity + pnl + unrealized_pnl
            # 记录净值 已实现盈亏
            self.equity = self.equity + pnl
            # 记录最高净值记录
            self.equity_high = max(self.equity_high, self.equity)
        # 结束本次回测
        # 更新上一次的行情记录
        self.last_marketdata = data

    # @timeit
    def run_by_tick(self, tradeMsg:model.TraderMsg):
        # 更新策略本地时间
        self.strategy.local_time = self.backtest_time
        # 执行信号
        self.handle_signal(self.signal_series)
        # 用最新行情进行撮合
        self.matching(tradeMsg.market)
        # 更新账户信息
        tradeMsg.cash = self.equity
        tradeMsg.orders = self.localOrders
        tradeMsg.position = self.pos
        # 产生本tick信号
        signal = self.strategy.onTime(tradeMsg)
        self.signal_series[self.backtest_time] = signal
        self.last_signal_time = self.backtest_time