def calculateBacktestingResult(self):
"""
计算回测结果
"""
#将交易结果化为dataframe
tradeResult = []
def todict(t):
return t.__dict__
for symbol in self.tradeDict.keys():
tradeResult.extend(self.tradeDict[symbol].values())
tradeResult = map(todict, tradeResult)
d = pd.DataFrame(tradeResult)
d = d.sort_values('dt')
index = pd.Index(np.arange(d.count()[0]))
d.index = index
self.output(u'计算回测结果')
# 首先基于回测后的成交记录，计算每笔交易的盈亏
self.resultList = [] # 交易结果列表
longTrade = {} # 未平仓的多头交易
shortTrade = {} # 未平仓的空头交易
symbolNow = '' # 当前的交易标的
for symbol in self.symbols:
longTrade[symbol] = []
shortTrade[symbol] = []
for i in range(d.count()[0]):
dict_ = d.ix[i].to_dict()
trade = VtTradeData()
trade.__dict__ = dict_
# 这些变量会被较多地引用，故先赋值
# if not symbolNow :
# symbolNow = trade.vtSymbol
if symbolNow != trade.vtSymbol:
symbolNow = trade.vtSymbol
commission = self.contractInfo[trade.vtSymbol]['commission']
slippage = self.contractInfo[trade.vtSymbol]['slippage']
size = self.contractInfo[trade.vtSymbol]['size']
margin = self.contractInfo[trade.vtSymbol]['margin']
elif symbolNow == trade.vtSymbol:
pass
# 多头交易
if trade.direction == DIRECTION_LONG:
# 如果尚无空头交易
if not shortTrade[symbolNow]:
longTrade[symbolNow].append(trade)
# 当前多头交易为平空
else:
while True:
entryTrade = shortTrade[symbolNow][0]
exitTrade = trade
# 清算开平仓交易
closedVolume = min(exitTrade.volume, entryTrade.volume)
result = TradingResult(symbolNow, entryTrade.price,
entryTrade.dt, exitTrade.price,
exitTrade.dt, -closedVolume,
commission, slippage, size,
margin)
#print BLUEPREFIX + str(result.pnl)
#print result.volume
self.resultList.append(result)
# 计算未清算部分
entryTrade.volume -= closedVolume
exitTrade.volume -= closedVolume
# 如果开仓交易已经全部清算，则从列表中移除
if not entryTrade.volume:
shortTrade[symbolNow].pop(0)
# 如果平仓交易已经全部清算，则退出循环
if not exitTrade.volume:
break
# 如果平仓交易未全部清算，
if exitTrade.volume:
# 且开仓交易已经全部清算完，则平仓交易剩余的部分
# 等于新的反向开仓交易，添加到队列中
if not shortTrade[symbolNow]:
longTrade[symbolNow].append(exitTrade)
break
# 如果开仓交易还有剩余，则进入下一轮循环
else:
pass
# 空头交易
else:
# 如果尚无多头交易
if not longTrade[symbolNow]:
shortTrade[symbolNow].append(trade)
# 当前空头交易为平多
else:
while True:
entryTrade = longTrade[symbolNow][0]
exitTrade = trade
# 清算开平仓交易
closedVolume = min(exitTrade.volume, entryTrade.volume)
result = TradingResult(symbolNow, entryTrade.price,
entryTrade.dt, exitTrade.price,
exitTrade.dt, closedVolume,
commission, slippage, size,
margin)
#print BLUEPREFIX + str(result.pnl)
#print result.volume
self.resultList.append(result)
# 计算未清算部分
entryTrade.volume -= closedVolume
exitTrade.volume -= closedVolume
# 如果开仓交易已经全部清算，则从列表中移除
if not entryTrade.volume:
longTrade[symbolNow].pop(0)
# 如果平仓交易已经全部清算，则退出循环
if not exitTrade.volume:
break
# 如果平仓交易未全部清算，
if exitTrade.volume:
# 且开仓交易已经全部清算完，则平仓交易剩余的部分
# 等于新的反向开仓交易，添加到队列中
if not longTrade[symbolNow]:
shortTrade[symbolNow].append(exitTrade)
break
# 如果开仓交易还有剩余，则进入下一轮循环
else:
pass
# 检查是否有交易
if not self.resultList:
self.output(u'无交易结果')
return {}
#将各标的交易的持仓区间用Series来表示持仓浮盈
floatProfit = defaultdict(list) #key为symbol，value是包含sr的list
df = self.dataframe.set_index(
'datetime').sort_index().drop_duplicates()
pnlList = []
for result in self.resultList:
symbolDf = df[df.symbol == result.symbol]
symbolDf = symbolDf[result.entryDt:result.exitDt] #+ delta]
symbolDf = symbolDf.drop_duplicates().sort_index()
sr = (
symbolDf['close'] - symbolDf.ix[0]['close']
) * result.size * self.contractInfo[result.symbol][
'margin'] * result.volume #- result.commission #- result.slippage
floatProfit[result.symbol].append(sr) #每笔交易区间的资金变化
pnlList.append(result.pnl) #每笔交易的利润
#===========================================================================
#print str(result.entryDt) + " =====> " + str(result.exitDt) + " ==========>>> " + str(result.pnl)
index = np.unique(df.index)
capitalSr = pd.Series(0, index=index)
for lsSymbol in floatProfit.values():
for floatSr in lsSymbol:
#print GREENPREFIX + str(floatSr) + "\n\n"
floatSr = pd.Series(floatSr, index=index)
floatSr = floatSr.fillna(method='ffill').fillna(0)
capitalSr += floatSr
capitalSr = capitalSr.drop_duplicates()
capitalSr = capitalSr + self.initCapital #可以看到回测期间的资金变化
pnlStat = pd.Series(pnlList) # 盈利序列
drawdownSr = capitalSr.cummax() - capitalSr # 回测序列
#===========================================================================
# 计算盈亏相关数据
winningRate = pnlStat[pnlStat > 0].count() / pnlStat.count() #胜率
averageWinning = pnlStat[pnlStat > 0].mean() # 平均每笔盈利
averageLosing = pnlStat[pnlStat < 0].mean() # 平均每笔亏损
profitLossRatio = -averageWinning / averageLosing # 盈亏比
#稳健指标计算
#回归年度回报率
lenSr = len(capitalSr)
m, b = np.polyfit(np.arange(lenSr), capitalSr.tolist(),
1) # 对资金曲线进行简单回归
expectedMonthlyReturn = lenSr * m / b # 回测收益率
testInterval = ((capitalSr.index[-1] - capitalSr.index[0]).days / 30.0
) # 测试区间对应的时间长度（月）
monthlyReturnRatio = expectedMonthlyReturn / testInterval #月化收益率
RAR = (1 + monthlyReturnRatio)**12 - 1 # 回归年度回报率
#稳健风险回报比率
temp = 0
maxDrawdownLs = []
for i in range(1, len(drawdownSr)):
if drawdownSr[i] == 0:
tempDrawdown = drawdownSr[temp:i].max()
if tempDrawdown != 0:
maxDrawdownLs.append(tempDrawdown)
temp = i
if len(maxDrawdownLs) >= 5:
aveDrawdown = np.mean(maxDrawdownLs[-5:]) # 五次最大回测的平均值
else:
aveDrawdown = np.mean(maxDrawdownLs) # 五次最大回测的平均值
RCube = RAR / aveDrawdown #稳健风险回报比率
# 返回回测结果
d = {}
d['capital'] = capitalSr[-1] / self.initCapital
d['maxCapital'] = capitalSr.max()
d['maxdrawdown'] = (pnlStat.cummax() - pnlStat).max()
d['maxdrawdownDay'] = drawdownSr.argmax().isoformat()
d['totalResult'] = pnlStat.count()
d['pnlList'] = pnlList
d['capitalSr'] = capitalSr
d['winningRate'] = winningRate
d['averageWinning'] = averageWinning
d['averageLosing'] = averageLosing
d['profitLossRatio'] = profitLossRatio
d['floatProfit'] = floatProfit
d['RAR'] = RAR
d['RCube'] = RCube
return d
