Alpha 对冲背景

作为普通的投资者，大部分投资者都会选择基金这一投资渠道。而面对眼花缭乱的基金产品，投资者如何选择出符合自己风险偏好的基金就显得十分重要。这一选择的过程可能就需要我们对基金产品做一个绩效评价，选出其中表现最好的作为我们的投资组合。而最常见的三个评价标准有下述三个：

1、夏普 (Sharpe) 指数：
美国经济学家威廉•夏普于 1966 年发表《共同基金的业绩》一文，提出用基金承担单位总风险（包括系统风险和非系统风险）所带来的超额收益来衡量基金业绩，这就是夏普指数。夏普指数通过一定评价期内，基金投资组合的平均收益超过无风险收益率部分与基金收益率的标准差之比来衡量基金的绩效。计算公式为：

Sp=Rp−Rfσp

Sp=Rp−RfσpSp=Rp−Rfσp

其中，SpSpSp 为夏普指数，RpRpRp 为基金组合的实际收益，RfRfRf 为无风险收益率，σpσpσp 为基金收益率所对应的标准差（σpσpσp 里既包括了系统风险也包括了特有风险）；也可见 CAPM 模型。
其直观含义是资产组合承担一单位的风险能够获得多少单位的额外收益。因此，可以认为，夏普业绩指数越大,基金绩效就越好；反之，基金绩效就越差。我们也可以通过图形做一个说明，以 CML（资本市场线）为例：在资本市场线以上的组合，其夏普比率较高，也就意味着承担单位的风险能获得更高的收益。

2、特雷诺 (Treynor) 指数简介
杰克•特雷诺 1965 年发表《如何评价投资基金的管理》一文，认为足够的证券组合可以消除单一资产的非系统性风险,那么系统风险就可以较好地刻画基金的风险，即与收益率变动相联系应为系统性风险。因此，特雷诺指数采用在一段时间内证券组合的平均风险报酬与其系统性风险对比的方法来评价投资基金的绩效。这就是特雷诺指数，它等于基金的超额收益与其系统风险测度β之比。
计算公式为：

Tp=Rp−Rfβp

Tp=Rp−RfβpTp=Rp−Rfβp

其中，TpTpTp 为特雷诺指数，βpβpβp 表示基金投资组合的 βββ 系数，是投资组合要承担的系统风险。
特雷诺业绩指数的理论依据也是资本资产定价模型（CAPM 模型），但是是以证券市场线（SML）为评价的基点，当市场处于平衡时，所有的资产组合都落在 SML 上，即 SML 的斜率就表示市场证券组合的特雷诺指数。当基金投资组合的特雷诺指数大于 SML 的斜率时， 该投资组合就位于 SML 线之上，表明其表现优于市场表现；反之，当基金投资组合的特雷诺指数小于 SML 的斜率时，该投资基金组合位于 SML 线之下，表明其表现劣于市场表现。所以，特雷诺业绩指数越大,基金的绩效就越好；反之，基金的绩效就越差。

3、詹森 (Jensen) 指数简介
美国经济学家迈克尔•詹森 1968 年发表《1945-1964年间共同基金的业绩》一文，提出了一种评价基金业绩德绝对指标，即詹森指数。他认为,基金投资组合的额外收益可衡量基金额外信息的价值,因而可以衡量基金的投资业绩，其计算公式为：

Jp=Rp−[Rf+βp⋅(Rm−Rf)]

Jp=Rp−[Rf+βp⋅(Rm−Rf)]Jp=Rp−[Rf+βp⋅(Rm−Rf)]

这里 JpJpJp 为詹森指数，其他符号如之前所定义。
詹森业绩指数,又称为 ααα 值,它反映了基金与市场整体之间的绩效差异。詹森指数也以资本资产定价模型为基础，根据 SML 来估计基金的超额收益率。其实质是反映证券投资组合收益率与按该组合的 βββ 系数算出来的均衡收益率之间的差额。当然，差额越大，也就是詹森系数越大,反映基金运作效果越好。如果 ααα 为正值，则说明基金经理有超常的选股能力,被评价基金与市场相比，高于市场平均水平，投资业绩良好；ααα 为负值则说明基金经理的选股能力欠佳,不能跑过指数,被评价基金的表现与市场相比较整体表现差；ααα 为零则说明基金经理的选股能力一般,只能与指数持平。

在策略中的应用

基于上面的逻辑，我们可以先选出一个 Alpha 较高并且稳定的交易策略组合，然后用沪深 300 股指期货进行对冲，以此以抵消掉系统性风险 βββ，并只剩下 ααα 的部分，使得我们的组合无论在牛熊市都能够获得稳定的收益。思路如下：假设策略选出的股票组合的超额收益为 ααα，组合收益 RpRpRp 与指数收益 RmRmRm 的线性相关系数为

βp=Cov(Rp,Rm)Var(Rm),

βp=Cov(Rp,Rm)Var(Rm),βp=Cov(Rp,Rm)Var(Rm),

（具体可见 CAPM 公式。）组合的收益可以用公式表示为：

Rp=α+βp⋅Rm.

Rp=α+βp⋅Rm.Rp=α+βp⋅Rm.

所以对于一单位的股票组合，卖空 βpβpβp 单位的股指期货可得到的收益为 ααα，按照这样的操作即可获得 ααα 的超额收益。

根据这个思路，我们构建一个策略：
(1) 首先找一个 Alpha 比较高的投资组合（此处我们以因子研究系列中的 ALR 因子为例）
(2) 设置两个仓位，一个用来交易股票，另一个用来交易股指期货。此外由于期货合约采取每日结算，并且当日卖出股票得到的现金要第二日才能转入期货账户，因此期货仓位中的钱除了满足保证金要求外，还要预留出能够扛两个涨停日的准备金。
(3) 设置调仓频率，根据资产负债率选择 ALR 指标最大的 3% 的股票作为新的股票组合。
(4) 每日跟踪期货账户准备金情况，如果发现准备金不足，应卖出一定量的股票来补充准备金并调整对冲的仓位。

回测结果

先看看我们不做 Alpha 对冲，回测的结果：

可以看出从 10 年 5 月到 16 年 11 月这一阶段，不做 Alpha 对冲可得的收益为 278%，但回撤较大，有 40%。做过对冲之后的结果如下：

可以发现后者放弃了很多的收益，但做过对冲后系统性风险基本为零，并且回撤回测明显减小，仅为 13%，而且完全没有受到股灾的影响。

结语

股指期货的规则和对冲的细节实际上比较复杂。比如说当指数发生变化之后，仓位里股票和股指期货空单就会分别发生一涨一跌的情况，对冲比例发生变化，应该及时调整仓位。又比如说任何时间点都有四个不同交割日期的沪深300期货合约，它们有着不同程度的折价或溢价，选择不同的日期的合约会带来一些差异。本文中没有考虑太多的细节，但这些都是值得考虑的，所以还有很大的提升空间。

函数和变量说明书

Deribit期权Delta动态对冲策略

本次FMZ量化带来的策略是Deribit期权Delta动态对冲策略，简称DDH（dynamic delta hedging）策略。

对于期权交易的学习，我们通常要掌握这几个方面的概念：

期权定价模型，B-S模型，期权价格根据【标的物价格】、【行权价】、【到期剩余时间】、【（隐含）波动率】、【无风险利率】确定价格。期权的风险敞口：
1、Delta — 期权的方向风险。如果Delta为+0.50，那这个期权，在标的价格涨跌时的盈亏表现，可视为0.50个现货。
2、Gamma — 方向风险的加速度。比如看涨期权，由于Gamma的作用，从标的价格位于行权价开始，价格不断上涨的过程中，Delta会从+0.50逐渐向+1.00靠拢。
3、Theta— 时间敞口。当你买入期权时，如果标的价格不动，每过一天，你会支付Theta金额所示的费用（Deribit以USD计价）。
当你卖出期权时，如果标的价格不动，每过一天，你会收到Theta金额所示的费用。
4、Vega — 波动率敞口。当你买入期权时，Vega为正，即做多波动率。隐含波动率提高时，你会在Vega敞口获得收益。反之亦然，当你卖出期权时，隐含波动率降低，你会获得收益。

DDH策略讲解：

DDH 原理讲解
通过配平期权和期货的Delta，达到交易方向的风险中性。由于期权的Delta是会跟随标的物价格变动而变动的，期货和现货的Delta是不变的。在持有期权合约仓位，并用期货对冲配平Delta之后，随着标的物价格变动，总体Delta会再次出现不平衡的状态。对于期权仓位和期货仓位这样的组合就需要持续的动态对冲配平Delta。

举个例子：
当我们买入了一张看涨期权，此时就持有了一个看多方向的头寸。此时需要做空期货来对冲期权的Delta，达到总体Delta中性（0或者接近于0）。我们先不考虑期权合约到期剩余时间、波动率等因素。
情况1：
标的物价格上涨，期权部分的Delta增大，总体Delta向正数移动，需要期货再次对冲，开一部分空头仓继续做空期货，使总体Delta再次平衡。（再次平衡前，此时期权的Delta大，期货的Delta相对小，看涨期权的边际盈利超过合约空头的边际损失，整个组合会出现收益）

情况2：
标的物价格下跌，期权部分的Delta减小，总体Delta向负数移动，平仓一部分空头的期货持仓，使总体Delta再次平衡。（再次平衡前，此时期权的Delta小，期货的Delta相对大，看涨期权的边际损失小于合约空头的边际盈利，整个组合还是会出现收益）。所以理想状态，标的物涨跌都会带来收益，只要市场有波动即可。然而还需要考虑的因素还有：时间价值、交易成本等因素。所以引用知乎大牛的解释：

Gamma Scalping 的关注点并不是delta，dynamic delta hedging 只是过程中规避underlying价格风险的一种做法而已。
Gamma Scalping 关注的是Alpha，此Alpha不是选股的Alpha，这里的Alpha = Gamma/Theta也就是单位Theta的时间损耗换来多少Gamma，
这个是关注的点。可以构建出上涨和下跌都浮盈的组合，但一定伴随时间损耗，那问题就在于性价比了。

作者：许哲
链接：https://www.zhihu.com/question/51630805/answer/128096385

DDH 策略设计讲解

• 聚合行情接口封装，框架设计
• 策略UI设计
• 策略交互设计
• 自动对冲功能设计

源码：

// 构造函数
function createManager(e, subscribeList, msg) {
	var self = {}
    self.supportList = ["Futures_Binance", "Huobi", "Futures_Deribit"]  // 支持的交易所的

    // 对象属性
    self.e = e
    self.msg = msg
    self.name = e.GetName()
    self.type = self.name.includes("Futures_") ? "Futures" : "Spot"
    self.label = e.GetLabel()
    self.quoteCurrency = ""  
    self.subscribeList = subscribeList   // subscribeList : [strSymbol1, strSymbol2, ...]
    self.tickers = []                    // 接口获取的所有行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.subscribeTickers = []           // 需要的行情数据，定义数据格式：{bid1: 123, ask1: 123, symbol: "xxx"}}
    self.accData = null 
    self.pos = null 

    // 初始化函数
    self.init = function() { 
    	// 判断是否支持该交易所
        if (!_.contains(self.supportList, self.name)) {        	
        	throw "not support"
        }
    }

    self.setBase = function(base) {
        // 切换基地址，用于切换为模拟盘
        self.e.SetBase(base)
        Log(self.name, self.label, "切换为模拟盘:", base)
    }

    // 判断数据精度
    self.judgePrecision = function (p) {
        var arr = p.toString().split(".")
        if (arr.length != 2) {
            if (arr.length == 1) {
                return 0
            }
            throw "judgePrecision error, p:" + String(p)
        }
        
        return arr[1].length
    }

    // 更新资产
    self.updateAcc = function(callBackFuncGetAcc) {
        var ret = callBackFuncGetAcc(self)
        if (!ret) {
        	return false 
        }
        self.accData = ret 
        return true 
    }

    // 更新持仓
    self.updatePos = function(httpMethod, url, params) {
        var pos = self.e.IO("api", httpMethod, url, params)
        var ret = []
        if (!pos) {
            return false 
        } else {
            // 整理数据
            // {"jsonrpc":"2.0","result":[],"usIn":1616484238870404,"usOut":1616484238870970,"usDiff":566,"testnet":true}
            try {
                _.each(pos.result, function(ele) {
                    ret.push(ele)
                })
            } catch(err) {
                Log("错误：", err)
                return false 
            }
            self.pos = ret
        }
        return true 
    }

    // 更新行情数据
    self.updateTicker = function(url, callBackFuncGetArr, callBackFuncGetTicker) {
    	var tickers = []
    	var subscribeTickers = []
    	var ret = self.httpQuery(url)
    	if (!ret) {
    		return false 
    	}
    	// Log("测试", ret)// 测试
    	try {
            _.each(callBackFuncGetArr(ret), function(ele) {
            	var ticker = callBackFuncGetTicker(ele)
            	tickers.push(ticker)
                if (self.subscribeList.length == 0) {
                    subscribeTickers.push(ticker)
                } else {
                	for (var i = 0 ; i < self.subscribeList.length ; i++) {                        
                    	if (self.subscribeList[i] == ticker.symbol) {
                    		subscribeTickers.push(ticker)
                    	}
                	}
                }
            })
        } catch(err) {
        	Log("错误：", err)
        	return false 
        }

        self.tickers = tickers
        self.subscribeTickers = subscribeTickers
        return true 
    }

    self.getTicker = function(symbol) {
    	var ret = null 
    	_.each(self.subscribeTickers, function(ticker) {
    		if (ticker.symbol == symbol) {
    			ret = ticker
    		}
    	})
    	return ret 
    }

    self.httpQuery = function(url) {
    	var ret = null
        try {
            var retHttpQuery = HttpQuery(url)
            ret = JSON.parse(retHttpQuery)
        } catch (err) {
            // Log("错误:", err)
            ret = null
        }
        return ret 
    }

    self.returnTickersTbl = function() {
        var tickersTbl = {
        	type : "table", 
        	title : "tickers",
        	cols : ["symbol", "ask1", "bid1"], 
        	rows : []
        }
        _.each(self.subscribeTickers, function(ticker) {        
        	tickersTbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1])
        })
        return tickersTbl
    }
    
    // 返回持仓表格
    self.returnPosTbl = function() {
        var posTbl = {
            type : "table", 
            title : "pos|" + self.msg,
            cols : ["instrument_name", "mark_price", "direction", "size", "delta", "index_price", "average_price", "settlement_price", "average_price_usd", "total_profit_loss"], 
            rows : []
        }
        /* 接口返回的持仓数据格式
        {
            "mark_price":0.1401105,"maintenance_margin":0,"instrument_name":"BTC-25JUN21-28000-P","direction":"buy",
            "vega":5.66031,"total_profit_loss":0.01226105,"size":0.1,"realized_profit_loss":0,"delta":-0.01166,"kind":"option",
            "initial_margin":0,"index_price":54151.77,"floating_profit_loss_usd":664,"floating_profit_loss":0.000035976,
            "average_price_usd":947.22,"average_price":0.0175,"theta":-7.39514,"settlement_price":0.13975074,"open_orders_margin":0,"gamma":0
        }
        */
        _.each(self.pos, function(ele) {
        	if(ele.direction != "zero") {
                posTbl.rows.push([ele.instrument_name, ele.mark_price, ele.direction, ele.size, ele.delta, ele.index_price, ele.average_price, ele.settlement_price, ele.average_price_usd, ele.total_profit_loss])
            }
        })
        return posTbl
    }

    self.returnOptionTickersTbls = function() {
        var arr = []
        var arrDeliveryDate = []
        _.each(self.subscribeTickers, function(ticker) {
            if (self.name == "Futures_Deribit") {
                var arrInstrument_name = ticker.symbol.split("-")
                var currency = arrInstrument_name[0]
                var deliveryDate = arrInstrument_name[1]
                var deliveryPrice = arrInstrument_name[2]
                var optionType = arrInstrument_name[3]

                if (!_.contains(arrDeliveryDate, deliveryDate)) {
                    arr.push({
                        type : "table", 
                        title : arrInstrument_name[1],
                        cols : ["PUT symbol", "ask1", "bid1", "mark_price", "underlying_price", "CALL symbol", "ask1", "bid1", "mark_price", "underlying_price"], 
                        rows : []
                    })
                    arrDeliveryDate.push(arrInstrument_name[1])
                }
                // 遍历arr
                _.each(arr, function(tbl) {
                    if (tbl.title == deliveryDate) {
                        if (tbl.rows.length == 0 && optionType == "P") {
                            tbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price, "", "", "", "", ""])
                            return 
                        } else if (tbl.rows.length == 0 && optionType == "C") {
                            tbl.rows.push(["", "", "", "", "", ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price])
                            return 
                        }                        
                        for (var i = 0 ; i < tbl.rows.length ; i++) {
                            if (tbl.rows[i][0] == "" && optionType == "P") {
                                tbl.rows[i][0] = ticker.symbol
                                tbl.rows[i][1] = ticker.ask1
                                tbl.rows[i][2] = ticker.bid1
                                tbl.rows[i][3] = ticker.mark_price
                                tbl.rows[i][4] = ticker.underlying_price
                                return 
                            } else if(tbl.rows[i][5] == "" && optionType == "C") {
                                tbl.rows[i][5] = ticker.symbol
                                tbl.rows[i][6] = ticker.ask1
                                tbl.rows[i][7] = ticker.bid1
                                tbl.rows[i][8] = ticker.mark_price
                                tbl.rows[i][9] = ticker.underlying_price
                                return 
                            }
                        }
                        if (optionType == "P") {
                            tbl.rows.push([ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price, "", "", "", "", ""])
                        } else if(optionType == "C") {
                            tbl.rows.push(["", "", "", "", "", ticker.symbol, ticker.ask1, ticker.bid1, ticker.mark_price, ticker.underlying_price])
                        }
                    }
                })
            }
        })
        return arr 
    }

    // 初始化
    self.init()
	return self 
}


function main() {
    // 初始化，清空日志
    if(isResetLog) {
    	LogReset(1)
    }

    var m1 = createManager(exchanges[0], [], "option")
    var m2 = createManager(exchanges[1], ["BTC-PERPETUAL"], "future")

    // 切换为模拟盘
    var base = "https://www.deribit.com"
    if (isTestNet) {    
        m1.setBase(testNetBase)    
        m2.setBase(testNetBase)
        base = testNetBase
    }

    while(true) {
        // 期权
        var ticker1GetSucc = m1.updateTicker(base + "/api/v2/public/get_book_summary_by_currency?currency=BTC&kind=option", 
            function(data) {return data.result}, 
            function(ele) {return {bid1: ele.bid_price, ask1: ele.ask_price, symbol: ele.instrument_name, underlying_price: ele.underlying_price, mark_price: ele.mark_price}}) 
        
        // 永续期货
        var ticker2GetSucc = m2.updateTicker(base + "/api/v2/public/get_book_summary_by_currency?currency=BTC&kind=future", 
            function(data) {return data.result}, 
            function(ele) {return {bid1: ele.bid_price, ask1: ele.ask_price, symbol: ele.instrument_name}})
        if (!ticker1GetSucc || !ticker2GetSucc) {
            Sleep(5000)
            continue
        }

        // 更新持仓
        var pos1GetSucc = m1.updatePos("GET", "/api/v2/private/get_positions", "currency=BTC&kind=option")
        var pos2GetSucc = m2.updatePos("GET", "/api/v2/private/get_positions", "currency=BTC&kind=future")

        if (!pos1GetSucc || !pos2GetSucc) {
            Sleep(5000)
            continue
        }

        // 交互
        var cmd = GetCommand()
        if(cmd) {
            // 处理交互
            Log("交互命令：", cmd)
            var arr = cmd.split(":")
            // cmdClearLog 
            if(arr[0] == "setContractType") {
                // parseFloat(arr[1])
                m1.e.SetContractType(arr[1])
                Log("exchanges[0]交易所对象设置合约：", arr[1])
            } else if (arr[0] == "buyOption") {
                var actionData = arr[1].split(",")
                var price = parseFloat(actionData[0])
                var amount = parseFloat(actionData[1])
                m1.e.SetDirection("buy")
                m1.e.Buy(price, amount)
                Log("执行价格：", price, "执行数量：", amount, "执行方向：", arr[0])
            } else if (arr[0] == "sellOption") {
                var actionData = arr[1].split(",")
                var price = parseFloat(actionData[0])
                var amount = parseFloat(actionData[1])
                m1.e.SetDirection("sell")
                m1.e.Sell(price, amount)                
                Log("执行价格：", price, "执行数量：", amount, "执行方向：", arr[0])
            } else if (arr[0] == "setHedgeDeltaStep") {
                hedgeDeltaStep = parseFloat(arr[1])
                Log("设置参数hedgeDeltaStep：", hedgeDeltaStep)
            } 
        }
        
        // 获取期货合约价格
        var perpetualTicker = m2.getTicker("BTC-PERPETUAL")
        var hedgeMsg = " PERPETUAL:" + JSON.stringify(perpetualTicker)

        // 从账户数据中获取delta总值        
        var acc1GetSucc = m1.updateAcc(function(self) {
        	self.e.SetCurrency("BTC_USD")        
        	return self.e.GetAccount()
        })
        if (!acc1GetSucc) {
        	Sleep(5000)
        	continue
        }
        var sumDelta = m1.accData.Info.result.delta_total

        if (Math.abs(sumDelta) > hedgeDeltaStep && perpetualTicker) {
            if (sumDelta < 0) {
                // delta 大于0 对冲期货做空                
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.ask1, -1)                
                if (amount > 10) {
                    Log("超过对冲阈值，当前总delta：", sumDelta, "买入期货")
                    m2.e.SetContractType("BTC-PERPETUAL")                    
                    m2.e.SetDirection("buy")
                    m2.e.Buy(-1, amount)
                } else {
                	hedgeMsg += ", 对冲下单量小于10"
                }
            } else {
                // delta 小于0 对冲期货做多
                var amount = _N(Math.abs(sumDelta) * perpetualTicker.bid1, -1)
                if (amount > 10) {
                    Log("超过对冲阈值，当前总delta：", sumDelta, "卖出期货")
                    m2.e.SetContractType("BTC-PERPETUAL")
                    m2.e.SetDirection("sell")
                    m2.e.Sell(-1, amount)
                } else {
                	hedgeMsg += ", 对冲下单量小于10"
                }
            }
        }

        LogStatus(_D(), "sumDelta:", sumDelta, hedgeMsg, 
        	"\n`" + JSON.stringify([m1.returnPosTbl(), m2.returnPosTbl()]) + "`", "\n`" + JSON.stringify(m2.returnTickersTbl()) + "`", "\n`" + JSON.stringify(m1.returnOptionTickersTbls()) + "`")
        Sleep(10000)
    }
}

策略参数：

策略地址：https://www.fmz.com/strategy/265090

策略运行：

本策略为教学策略，学习为主，实盘请谨慎使用。