融资融券策略回测使用说明及回测案例

我们基于 DolphinDB 的回测插件实现使用融资业务为投资组合策略增加杠杆的策略回测。本案例基于股票日频行情根据因子选择组合进行策略回测。

组合策略的因子选择不是本文的重点，这里假设选股的因子为 signal。这里的选股因子可以是一个单因子也可以是多个因子合成的信号。本节组合策略实现逻辑如下：

• 首先以 signal 为指标，在每个交易日收盘时，从沪深300成分股中根据 signal 的值的排名选取靠前的 10 只股票。把当前的总资产按 signal 加权分配给这 10 只股票进行买入。
• 每个交易日开仓时，用当前最新资产的 150% 建立整体仓位，即先用现金买入持仓再通过融资买入建立整体仓位。

在实现中我们在买入卖出时考虑涨停、跌停和停牌的情况。当涨停和停牌时不能买入，跌停和停牌时不能卖出。这里，我们通过自定义的函数实现涨停和停牌时不能买入，跌停和停牌时不能卖出以及每次买入数量的函数。如下，我们实现的 3 个自定义函数，通过行情数据中带有的涨停价是否与当前的收盘价相等，当日的成交量是否为零等，判断是否可以买入或者卖出股票。买入的股票数量必须为 100 的整数倍，且买入科创板股票的数量必须大于 200 股。

def isBuyAble(data){
	//判断是否可以以收盘价买入
	if(data.volume <= 0.001 or (data.upLimitPrice == data.close)){
		return false //买入条件：收盘价不是涨停价，当日没有停牌
	}
	return true
}
def isSellAble(data){
	//判断是否可以以收盘价卖出
	if(data.volume <= 0.001 or (data.downLimitPrice == data.close)){
		return false //卖出条件：收盘价不是跌停价，当日没有停牌
	}
	return true
}
def getBuyVolume(istock,mv,close){
	if(close <= 0. ) {return 0}
	if(istock.substr(0,2) == "68" and int(mv/close) >= 200){
		return floor(mv/close)
	}
	else if(istock.substr(0,2) == "68"){ return 0}
	return floor(int(mv/close)/100)*100
}

回测引擎采用事件驱动机制，我们在相应的事件函数中实现相关的策略逻辑。首先在策略初始化回调函数 initialize中初始化策略全局变量。这里我们设置策略中组合的个数，组合策略杠杆倍数等全局变量。

def initialize(mutable context, userParam){
	print("initialize")
	context["N"] = 10 //策略组合个数
	//策略整体仓位比例，该比例大于1时，表示组合部分标的通过融资买入建立持仓
	context["multiplier"] = 1.5
	context["commission"] = userParam["commission"] //手续费
	context["Holdings"] = array(STRING,0,context["N"])//持仓		
}

在每日盘前回调交易函数中，可以初始化当日的全局变量。在这里我们获取当日标的是否可以进行融资买入信息。

def beforeTrading(mutable context,userParam){
	print ("beforeTrading: "+context["tradeDate"])
	//获取当日标的是否可以进行融资买入信息
	context["eligibleForMarginTrading"] = userParam[date(context["tradeDate"])]	
} 

在主要的行情回调函数 onBar 中，策略的实现分为 5 个步骤实现，大致如下：

def onBar(mutable context, msg, indicator){
	//每个交易日收盘时，用当前最新资产的150%建立整体仓位，即先用现金买入持仓再通过融资买入建立整体仓位
	//step 1 :获取当日可以进行买入的股票池，获取因子值前context["N"]个股票进行买入，
	...
	//step 2: 获取当前持仓，检查是否有不能卖出的股票,获取不能卖出的持仓市值
	...
	//step 3：获取策略当前的总资产减去不能卖出的总市值为当前可分配的市值，再计算买入个股实际应该占用的市值
	...
	//step 4:先进行卖出操作，卖出实际需要卖出的部分
	...
	//step 5:买入操作。买入,先用现金买入当日不可融资买入的标的		
}

下面我们分别展示 onBar 回调函数中 5 个步骤的详细代码实现：

step 1，我们获取当日可以进行买入的股票池和相应的权重。根据因子值的大小，获取因子值前 context["N"] 只股票和相应的权重。

//每个交易日收盘时，用当前最新资产的150%建立整体仓位，即先用现金买入持仓再通过融资买入建立整体仓位
//step 1 :获取当日可以进行买入的股票池，获取因子值前context["N"]个股票进行买入，
buyList = array(STRING, 0, context["N"])
buyWeight = array(DOUBLE, 0, context["N"])
eligibleForMarginTradingLaBel =  array(INT, 0, context["N"])
//获取当日可以进行买入的股票池，根据前一日因子值，获取因子值前context["N"]个股票进行买入，
//如果有停牌，涨停的情况，买入数量小于context["N"]
i = 0
for( istock in msg.keys()){
	if(i > context["N"] ){ break }
	if(msg[istock].signal[0] <0. ){ continue}
	if(isBuyAble(msg[istock])){//可以进行买入
		buyList = buyList.append!(istock)
		buyWeight = buyWeight.append!(msg[istock].signal[0])
		eligibleForMarginTradingLaBel = eligibleForMarginTradingLaBel.append!(int(context["eligibleForMarginTrading"][istock]))
	}
	i = i+1
}

step 2，计算当日停牌或者跌停不能进行卖出的股票占用的总市值。

//step 2
//获取当前持仓，检查是否有不能卖出的股票
MarginSecuPosition = Backtest::getMarginSecuPosition(context["engine"])
MarginTradingPosition = Backtest::getMarginTradingPosition(context["engine"])
posStock =keys( set(MarginSecuPosition.symbol ) | set(MarginTradingPosition.symbol))
//记录不能卖出的持仓市值
noSellPosMV = 0.
for(istock in posStock){
	if(isSellAble(msg[istock]) == false){//不能卖出
		//计算不能卖出的股票占用的市值
		pos = getPos(MarginSecuPosition, istock) + getPos(MarginTradingPosition, istock) 
		mv = pos*msg[istock].close
		if(mv > 0.){
			noSellPosMV = noSellPosMV + mv
		}	
	}
}

这里的 Backtest::getMarginSecuPosition 和 Backtest::getMarginTradingPosition 分别是获取当前担保品买入持仓和融资买入持仓的接口。详见 2.3 融资融券相关接口说明。

step 3，获取待买入股票池和不能卖出的总市值之后，计算待买入股票相应的市值。

//step 3
//权重归因化
buyWeight = buyWeight\buyWeight.sum()
//获取策略当前的总资产
totalEquity = Backtest::getTotalPortfolios(context["engine"]).totalEquity[0]
//计算个股应该买入的市值（）
totalMarketValue = (totalEquity - noSellPosMV) *buyWeight*context["multiplier"]

这里的 Backtest::getTotalPortfolios(engine)接口可以实现获取策略最新的可以现金，权益和盈亏等统计指标。详见 2.3 融资融券相关接口说明。

step 4，我们对可以卖出的股票进行担保品卖出操作，这样可以释放资金。在卖出时我们没有进行全部的卖出，而是卖出需要卖出的部分市值，这样可以减少手续费扣除。

//step 4
//根据应该持有的市值进行买入
//先进行卖出操作，再进行买入
newStock = (set(buyList) - set(posStock)).keys()
for(istock in posStock){//进行卖出
	if(isSellAble(msg[istock])){
		//查询当前持仓，有可有能是担保品买入持仓，也有可能是融资买入持仓	
		mv = (getPos(MarginSecuPosition, istock) + getPos(MarginTradingPosition, istock))*msg[istock].close
		diffmv = mv - totalMarketValue[at(buyList == istock)].nullFill(0)[0]
		pos = getBuyVolume(istock, diffmv, msg[istock].close)
		if(diffmv > 0 and pos >0  ){
			//进行担保品卖出
			Backtest::submitOrder(context["engine"], (istock,context["tradeTime"], 5, msg[istock].close, pos,2),"担保品卖出")
		}		
	}	
}

这里的 Backtest::submitOrder 是回测引擎提供的下单接口，详见 2.3 融资融券相关接口说明。注意，担保品卖出时优先偿还融资买入的持仓，所以这里我们只需进行担保品卖出操作。

step 5，在我们通过杠杆交易构建买入组合时，即先使用现金买入不可融资买入的股票，再使用融资买入当日可以进行融资买入的股票。

//step 5：买入操作
buyList = buyList[isort(eligibleForMarginTradingLaBel)]
totalMarketValue = totalMarketValue[isort(eligibleForMarginTradingLaBel)]
i = 0
for( istock in buyList){
	a =  getPos(Backtest::getMarginSecuPosition(context["engine"], [istock]), istock)
	b =  getPos(Backtest::getMarginTradingPosition(context["engine"], [istock]), istock)
	mv = (a + b)*msg[istock].close
	diffmv = totalMarketValue[i].nullFill(0)[0] - mv
	pos = getBuyVolume(istock, diffmv, msg[istock].close)
	availableCash = Backtest::getTotalPortfolios(context["engine"]).availableCash
	if(diffmv > 0 and pos >0  and pos*msg[istock].close*(1+context["commission"]) < availableCash){
		//进行担保品买入
		Backtest::submitOrder(context["engine"], (istock,context["tradeTime"], 5, msg[istock].close, pos,1),"担保品买入")
	}
	else if( diffmv > 0 and pos >0  and pos*msg[istock].close*(1+context["commission"]) > availableCash ){
		//进行融资买入
		Backtest::submitOrder(context["engine"], (istock,context["tradeTime"], 5, msg[istock].close, pos,3),"融资买入")	
	}
	i = i+1		
}

策略编写完成之后，我们需要配置策略相关的参数、再创建相应的回测引擎、之后获取行情数据进行策略回测就可以获取策略的回测结果。

设置配置项

融资融券策略回测，除了需要设置策略回测的开始和结束时间、策略类型和行情类型之外、还必须融资融券授信额度、维保比例、融资利率和融券利率。多头集中度限制和空头集中度限制用户可以根据实际需求进行相应的设置。如下列出了部分配置参数，完整的配置参数列表请参阅 回测插件接口说明文档。

// step 2：策略配置与引擎创建
config = dict(STRING,ANY)
config["startDate"] = 2020.05.08
config["endDate"] = 2020.07.11
///策略类型,股票信用账户，融资融券回测///
config["strategyGroup"] = "securityCreditAccount"
config["lineOfCredit"] = 100000000.//授信额度
config["marginTradingInterestRate"] = 0.086
config["secuLendingInterestRate"] = 0.106
config["maintenanceMargin"] = [1.45,1.30,1.20]//维保比例
//config["longConcentration"] = [1.45,1.30,1.20]//多头集中度限制
//config["shortConcentration"] = [1.45,1.30,1.20]//空头集中度限制
config["cash"] = 5000000.   
config["commission"] = 0.0///手续费,    
config["tax"] = 0.0 //印花税,
config["dataType"] = 4 //日频行情
config["outputOrderInfo"] = true
config["matchingMode"] = 1//以收盘价撮合
config["msgAsTable"] = false

创建回测引擎

engine = Backtest::createBacktestEngine(strategyName, config, securityReference, 
            initialize{, config},beforeTrading{,eligibleForMarginTrading},onBar,,
            onOrder,onTrade,afterTrading,finalize)

这里的Backtest::createBacktestEngine 接口为创建两融回测引擎的接口，详见 2.3 融资融券相关接口说明。

执行回测引擎

通过以下方式执行回测。其中dayData为行情数据，具体的行情字段说明参考股票。

//开始执行策略回测
Backtest::appendQuotationMsg(engine, dayData)

这里我们基于因子构建组合策略。我们先将相应的因子数据放入行情数据的 signal 字段中，并在策略中实现获取因子值的前几个股票构成组合。在这里我们把 dayData 也按时间和因子值进行排序处理再回放给回测引擎。

获取回测结果

回测运行结束之后，可以通过相应的接口获取每日持仓、每日权益、收益概述、成交明细和策略中用户自定义的逻辑上下文。回测插件提供的完整回测结果接口可以参阅回测插件的接口说明文档。

通过 Backtest::getTradeDetails(engine) 接口获取成交明细表如下。其中 orderInfo 不为空时表示拒单，orderInfo 列详细说明了的拒单理由。

通过 Backtest::getDailyTotalPortfolios(engine) 接口可以获取策略每日的净值，权益等统计信息。

totalPortfolios = Backtest::getDailyTotalPortfolios(long(engine))
plot(totalPortfolios.netValue,totalPortfolios.tradeDate,"策略净值")

本节示例实现逻辑如下：

• 创建引擎时使用现金的 95% 买入相应的股票。
• 监控相应的标的池，借用 RSI 和布林带指标：
  • 当有标的的 RSI 大于70 且布林带正在上移并打破上轨，使用账户的可用保证金余额进行融资买入。
  • 当有标的的 RSI 小于 30 且布林带正在下移并打破下轨，使用账户的可用保证金余额进行融券卖出。
• 止盈止损：
  • 当融资买入或者融券卖出的标的盈利 5% 或者亏损 3% 时，进行平仓。

用户在进行真实的策略回测时，可以在 config 的配置项 setLastDayPosition 中对初始仓位标的的持仓量和持仓价格等信息进行设置，初始仓位表详细字段见表 3。在这里的实现逻辑中，我们假设使用策略现金的 95% 用来买入 2 只股票，使得策略的初始现金为剩下的 5%。

//设置初始仓位，使用现金的95%为底仓
config["cash"] = 5000000.   
n = 2//底仓标的个数
mv = config["cash"] *0.95 / n
setLastDayPosition = select symbol,each(getBuyVolume{, mv, },symbol,open) $ LONG as marginSecuPosition,
			open as marginSecuAvgPrice, 0$LONG as marginPosition, 0. as marginBuyValue, 0$LONG as secuLendingPosition,
			0. as secuLendingSellValue, open as closePrice, 0.8 as conversionRatio, 
			0. as tradingMargin, 0. as lendingMargin  from getLastClosePrice(config["startDate"], codes[:n]) 

config["setLastDayPosition"] = setLastDayPosition
//设置策略现金
config["cash"] = config["cash"] -  config["cash"] *0.95*(1 + config["commission"])

在策略实现中我们通过 ta 模块的 rsi 和 bBand函数实现 RSI 和布林带指标。

use ta
def initialize(mutable context, userParam){
	print("initialize")
	d ={rsi : <ta::rsi(close, 11)>, 
		bhigh : <ta::bBands(close, 20, 2, 2, 0)[0]>, 
		blow : <ta::bBands(close, 20, 2, 2, 0)[2]>}
	Backtest::subscribeIndicator(context["engine"], "ohlc", d)
	context["tp"] = 0.05
	context["sl"] = 0.03	
	context["HoldingsPrice"] = dict(STRING,DOUBLE)
	
}

指标的计算可以使用引擎提供的 Backtest::subscribeIndicator 接口。订阅指标之后，在 onBar策略回调函数中通过 msg[istock].rsi 获取相应的指标计算结果。该接口使用示例如下：

Backtest::subscribeIndicator(engine, quote, indicatorDict)

indicatorDict = {rsi : <ta::rsi(close, 11)>, 
		bhigh : <ta::bBands(close, 20, 2, 2, 0)[0]>, 
		blow : <ta::bBands(close, 20, 2, 2, 0)[2]>}

在分钟频率行情回调函数中，我们对标的池中的股票，使用布林带突破和 RSI 作为开仓信号进行融资买入、或者融券卖出操作。首先使用 Backtest::getMarginTradingPosition 和 Backtest::getSecuLendingPosition 接口查询融资买入和融券卖出的持仓。没有持仓时，当该标的的 RSI 大于 70 且布林带正在上移并打破上轨，使用账户的可用保证金余额进行融资买入，当该标的的 RSI 小于 30 且布林带正在下移并打破下轨，使用账户的可用保证金余额进行融券卖出。有持仓时，以分钟行情实时进行风险监控进行止盈或者止损操作，对融资买入的持仓进行卖券还款，对融资卖出的持仓进行买券还券。具体代码实现如下：

def onBar(mutable context, msg, indicator){
	for( istock in msg.keys()){
		longPosition = Backtest::getMarginTradingPosition(context.engine, [istock]).longPosition[0]
		shortPosition = Backtest::getSecuLendingPosition(context.engine, [istock]).shortPosition[0]
		close = msg[istock].close
		open = msg[istock].open
		if(msg[istock].rsi > 70. and close > msg[istock].bhigh and close > open and longPosition < 1 and shortPosition < 1 ){
		     	//进行融资买入
		     	availableMarginBalance = Backtest::getTotalPortfolios(context.engine).availableMarginBalance[0]
			qty = getBuyVolume(istock, availableMarginBalance*0.2, close)
			if( qty > 0){
				Backtest::submitOrder(context.engine, (istock, context.tradeTime, 5, close, qty, 3), "融资买入")	
				context["HoldingsPrice"][istock] = close
			}	
	    	}
		if(msg[istock].rsi < 30. and close < msg[istock].blow  and close < open and  longPosition < 1 and shortPosition <1){
			//有担保品买入持仓时，不进行融券卖出
			pos = Backtest::getMarginSecuPosition(context.engine, [istock]).longPosition[0]
			availableMarginBalance = Backtest::getTotalPortfolios(context.engine).availableMarginBalance[0]
			qty = getBuyVolume(istock, availableMarginBalance*0.2, close)
			if(pos < 1 and qty > 0){
			     	 //进行融券卖出
				Backtest::submitOrder(context.engine, (istock, context.tradeTime, 5, close, qty, 4), "融券卖出")
				context["HoldingsPrice"][istock] = close
			}		
		}
		if (longPosition > 0  and (close >= context["HoldingsPrice"][istock] * ( 1+ context["tp"]) or 
					close <= context["HoldingsPrice"][istock] * ( 1 - context["sl"]))){
			//止损或者止盈
			Backtest::submitOrder(context.engine, (istock, context.tradeTime, 5, close, longPosition, 6), "卖券还款")					
		}
		if (shortPosition > 0  and (close <= context["HoldingsPrice"][istock] * ( 1 - context["tp"]) or 
					close >= context["HoldingsPrice"][istock] * ( 1 + context["sl"]))){
			//止损或者止盈
			Backtest::submitOrder(context.engine, (istock, context.tradeTime, 5, close, shortPosition, 8), "买券还券")					
		}		
	}
}

通过如下操作执行策略回测：

timer Backtest::appendQuotationMsg(engine, minData)

最后，我们通过 Backtest::getDailyTotalPortfolios(engine) 接口获取策略的净值以及初始仓位的净值。

totalPortfolios = Backtest::getDailyTotalPortfolios(engine)
//回测结果综合展示
netValue = totalPortfolios.netValue
bottomNetValue = totalPortfolios.bottomNetValue
plot([netValue,bottomNetValue], totalPortfolios.tradeDate, "策略净值")

本节案例完整代码见附件。