缘起：一个看起来很美的套利梦

最近刷知乎，刷到一篇标题很诱人的帖子：《币圈稳定暴富方法，3000U三个月稳定盈利到12000U》。

我就笑了，稳定？暴富？这两个词放在一起，一般就两种可能：要么是骗子，要么是还没遇到黑天鹅的人。

但是，作为一个量化交易开发者，看到这种策略描述，还是忍不住要点进去瞧瞧。

这套理论是这么说的：

1. BTC是币圈龙头，涨跌幅度肯定比小弟们（ETH、SOL等）更大
2. 牛市来了：BTC涨得猛 → 做多BTC + 做空ETH → 稳赚差价
3. 熊市来了：BTC跌得狠 → 做空BTC + 做多ETH → 还是稳赚差价

看完我陷入了沉思……

似乎，也许，可能，大概，hope，wish，maybe有点道理？

第一版代码：天真的开始

话不多说，打开发明者量化平台，开干！

最简单的逻辑：

            javascript
            
            
// 伪代码
if (btcChange > 2%) {
    开多 1手 BTC
    开空 1手 ETH
}

写完之后信心满满地点击回测，然后……

亏成狗了。

看着那条直线往下掉的权益曲线，我陷入了深深的自我怀疑。

第二版代码：科学的对冲

问题出在哪？Beta对冲的艺术

冷静下来想想，问题很明显：

1手BTC ≠ 1手ETH

BTC现在10万刀一个，ETH才3千多刀，你拿1：1的数量去对冲，这不是对冲，这是送钱。

真正的对冲策略，需要考虑：

• 价格比例：BTC/ETH ≈ 30：1
• 波动率差异：两者的收益率相关性
• 合约面值：OKX的BTC永续1张=0.01BTC，ETH永续1张=0.1ETH

Beta对冲的完整实现

这段代码是策略的核心计算引擎，它完整实现了ETH相对于BTC的Beta系数计算。Beta系数在这里代表了两个关键信息：基础价格比例关系和波动联动性，它直接决定了需要对冲的比例。

            javascript
            
            
// 计算ETH相对BTC的Beta系数
function calculateBeta(btcRecords, ethRecords, lookback) {
    // 数据不足时的降级处理
    if (btcRecords.length < lookback + 1 || ethRecords.length < lookback + 1) {
        Log("⚠️ K线数据不足，使用当前价格比作为默认Beta")

        let btcPrice = btcRecords[btcRecords.length - 1].Close
        let ethPrice = ethRecords[ethRecords.length - 1].Close
        let defaultBeta = btcPrice / ethPrice

        betaInfo.currentBeta = defaultBeta
        betaInfo.correlation = 0
        betaInfo.priceRatio = defaultBeta
        betaInfo.returnBeta = 1.0
        betaInfo.lastUpdate = new Date().toLocaleString()

        Log("  默认Beta =", _N(defaultBeta, 2), "| 价格比：", _N(btcPrice, 0), "/", _N(ethPrice, 0))
        return defaultBeta
    }

    let btcReturns = []
    let ethReturns = []
    let priceRatios = []

    // 第一步：计算日收益率 + 历史价格比
    for (let i = btcRecords.length - lookback; i < btcRecords.length; i++) {
        // 日收益率 = (今日收盘 - 昨日收盘) / 昨日收盘
        let btcRet = (btcRecords[i].Close - btcRecords[i-1].Close) / btcRecords[i-1].Close
        let ethRet = (ethRecords[i].Close - ethRecords[i-1].Close) / ethRecords[i-1].Close

        btcReturns.push(btcRet)
        ethReturns.push(ethRet)

        // 记录每天的价格比
        let ratio = btcRecords[i].Close / ethRecords[i].Close
        priceRatios.push(ratio)
    }

    // 第二步：计算历史平均价格比
    let avgPriceRatio = priceRatios.reduce((a, b) => a + b, 0) / priceRatios.length

    // 第三步：计算价格比的波动性
    let priceRatioVariance = 0
    for (let i = 0; i < priceRatios.length; i++) {
        let diff = priceRatios[i] - avgPriceRatio
        priceRatioVariance += diff * diff
    }
    priceRatioVariance /= (priceRatios.length - 1)
    let priceRatioStd = Math.sqrt(priceRatioVariance)
    let priceRatioCv = priceRatioStd / avgPriceRatio  // 变异系数

    // 第四步：计算收益率的均值
    let btcMean = btcReturns.reduce((a,b) => a+b, 0) / btcReturns.length
    let ethMean = ethReturns.reduce((a,b) => a+b, 0) / ethReturns.length

    // 第五步：计算协方差和方差
    let covariance = 0
    let btcVariance = 0
    let ethVariance = 0

    for (let i = 0; i < btcReturns.length; i++) {
        let btcDiff = btcReturns[i] - btcMean
        let ethDiff = ethReturns[i] - ethMean
        covariance += btcDiff * ethDiff
        btcVariance += btcDiff * btcDiff
        ethVariance += ethDiff * ethDiff
    }

    covariance /= (btcReturns.length - 1)
    btcVariance /= (btcReturns.length - 1)
    ethVariance /= (ethReturns.length - 1)

    // 第六步：计算收益率Beta
    // Beta = Cov(ETH, BTC) / Var(BTC)
    let returnBeta = covariance / btcVariance

    // 第七步：计算相关系数
    // 相关系数 = Cov(ETH, BTC) / (Std(BTC) × Std(ETH))
    let correlation = covariance / Math.sqrt(btcVariance * ethVariance)

    // 第八步：最终Beta = 历史平均价格比 × 收益率Beta
    let finalBeta = avgPriceRatio * returnBeta

    // 第九步：限制Beta范围，避免极端值
    let minBeta = avgPriceRatio * 0.5
    let maxBeta = avgPriceRatio * 2.0
    finalBeta = Math.max(minBeta, Math.min(maxBeta, finalBeta))

    // 第十步：获取当前价格比
    let currentBtcPrice = btcRecords[btcRecords.length - 1].Close
    let currentEthPrice = ethRecords[ethRecords.length - 1].Close
    let currentPriceRatio = currentBtcPrice / currentEthPrice

    // 更新Beta信息到全局
    betaInfo.currentBeta = finalBeta
    betaInfo.correlation = correlation
    betaInfo.returnBeta = returnBeta
    betaInfo.avgPriceRatio = avgPriceRatio
    betaInfo.currentPriceRatio = currentPriceRatio
    betaInfo.priceRatioStd = priceRatioStd
    betaInfo.priceRatioCv = priceRatioCv
    betaInfo.lastUpdate = new Date().toLocaleString()

    return finalBeta
}

主要功能与逻辑：

1. 数据验证与降级处理：检查历史数据是否足够，不足时直接使用当前价格比，确保策略始终可运行。
2. 收益率序列计算：将价格数据转换为收益率，消除了绝对价格的量纲影响，使不同价格的资产可以比较。
3. 统计分析核心计算：
   • 协方差：衡量BTC和ETH收益率联动的方向和强度。
   • 方差：衡量BTC收益率自身的波动程度。
   • 收益率Beta：Cov(ETH,BTC) / Var(BTC)，表示ETH收益对BTC收益变动的敏感度。
   • 相关系数：标准化后的协方差，反映线性相关程度。
4. 综合Beta合成：最终Beta = 历史平均价格比 × 收益率Beta。这样既考虑了基础价格差异（如BTC是ETH的30倍），又考虑了波动特性差异（如ETH波动是BTC的0.8倍）。例如，若价格比为30，收益率Beta为0.8，则最终Beta=24，意味着对冲1个BTC需要24个ETH。
5. 风险控制机制：对Beta值设置合理范围限制，防止因短期极端行情计算出不合理的对冲比例。

有了Beta之后，还需要解决“理论与现实之间的差距”，将理论系数转化为交易所实际可交易的数量。这部分代码完成了这个关键转换。

            javascript
            
            
// 计算对冲张数
function calculateHedgeAmount(beta) {
    let btcCoinAmount = config.btcCoinAmount  // 0.1 BTC
    let ethCoinAmount = btcCoinAmount * beta  // ETH数量 = 0.1 × Beta

    // 转换成合约张数
    let btcContracts = Math.floor(btcCoinAmount / contractInfo.btcCtVal)
    btcContracts = Math.max(1, btcContracts)  // 至少1张

    let ethContracts = Math.floor(ethCoinAmount / contractInfo.ethCtVal)
    ethContracts = Math.max(1, ethContracts)

    // 实际开仓的币数
    let actualBtcCoins = btcContracts * contractInfo.btcCtVal
    let actualEthCoins = ethContracts * contractInfo.ethCtVal

    Log("🎯 对冲计算 | Beta：", _N(beta, 3),
        "\n  BTC： ", _N(actualBtcCoins, 4), "币 =", btcContracts, "张 (CtVal：", contractInfo.btcCtVal, ")",
        "\n  ETH： ", _N(actualEthCoins, 4), "币 =", ethContracts, "张 (CtVal：", contractInfo.ethCtVal, ")",
        "\n  实际比例：", _N(actualEthCoins / actualBtcCoins, 3))

    return {
        btc: btcContracts,
        eth: ethContracts,
        btcCoins: actualBtcCoins,
        ethCoins: actualEthCoins,
        beta: beta
    }
}

关键转换步骤：

1. 确定基础头寸规模：根据配置设定基准BTC数量（如0.1个），作为整个对冲组合的“锚”。
2. 理论币数计算：ETH理论数量 = BTC基准数量 × Beta系数。
3. 合约面值转换：最关键的实际操作步骤。将理论币数除以各自合约的“合约面值”（CtVal），例如BTC合约1张可能代表0.01个BTC，ETH合约1张代表0.1个ETH，从而得到合约张数。
4. 整数化处理：使用向下取整确保交易为整数张合约，并至少为1张。同时反向计算实际交易的比例，用于后续精确的盈亏计算。

开仓与平仓逻辑

这是策略的执行和风控部分，将计算好的对冲方案转化为实际的交易操作，并管理风险。这里展示开仓逻辑，以多仓为例，空仓可按照镜像理解。

触发条件设计：采用双重条件——BTC涨幅>2% 且 BTC涨幅>ETH涨幅。这确保了市场有足够波动，且预期的相对强弱关系成立。

            javascript
            
            
// BTC涨 > 2% 且涨幅大于ETH → 开多BTC + 开空ETH
if (btcChange > 0.02 && btcChange > ethChange) {
    let amounts = calculateHedgeAmount(beta)

    // 先开BTC多单
    let btcOrder = createMarketOrder(config.btcSymbol, "buy", amounts.btc)
    if (!btcOrder) {
        Log("❌ BTC开多失败")
        return null
    }

    // 再开ETH空单
    let ethOrder = createMarketOrder(config.ethSymbol, "sell", amounts.eth)
    if (!ethOrder) {
        Log("❌ ETH开空失败，回滚BTC")
        createMarketOrder(config.btcSymbol, "closebuy", amounts.btc)
        return null
    }

    Log("🟢 开仓完成 | Beta：", _N(beta, 3))
}

原子化交易执行：顺序执行并带有回滚机制。先开BTC多单，成功后再开ETH空单；如果ETH下单失败，则立即平掉已开的BTC多单，确保头寸完整，避免暴露单边风险。

下面是平仓逻辑的展示：

按币数计算盈亏：根据开仓币数进行两个仓位的合计盈亏，计算综合对冲效果。

• BTC多单盈亏 = (当前价 - 开仓价) × 持有BTC币数
• ETH空单盈亏 = (开仓价 - 当前价) × 持有ETH币数

风控阈值设置：对组合整体表现进行评估，设定非对称的止盈（+3%）止损（-1%）线，追求正期望值。

            javascript
            
            
// 按币数计算盈亏
function checkClose(pos, btcTicker, ethTicker) {
    let btcPnlUsd, ethPnlUsd

    if (pos.type === 'long_btc_short_eth') {
        // BTC多单盈亏 = (当前价 - 开仓价) × 币数
        btcPnlUsd = (btcTicker.Last - pos.btcPrice) * pos.btcCoinAmount
        // ETH空单盈亏 = (开仓价 - 当前价) × 币数
        ethPnlUsd = (pos.ethPrice - ethTicker.Last) * pos.ethCoinAmount
    } else {
        btcPnlUsd = (pos.btcPrice - btcTicker.Last) * pos.btcCoinAmount
        ethPnlUsd = (ethTicker.Last - pos.ethPrice) * pos.ethCoinAmount
    }

    let totalPnlUsd = btcPnlUsd + ethPnlUsd
    let totalCost = pos.btcPrice * pos.btcCoinAmount + pos.ethPrice * pos.ethCoinAmount
    let totalPnlPct = totalPnlUsd / totalCost

    // 止盈： +3%
    if (totalPnlPct >= 0.03) {
        return {close: true, reason: '✅止盈', pnl: totalPnlPct, pnlUsd: totalPnlUsd}
    }
    // 止损： -1%
    if (totalPnlPct <= -0.01) {
        return {close: true, reason: '🛑止损', pnl: totalPnlPct, pnlUsd: totalPnlUsd}
    }

    return {close: false, pnl: totalPnlPct, pnlUsd: totalPnlUsd}
}

再次回测，结果……

曲线终于往上走了！

回测数据分析

从2025年10月到2026年1月，约3个月时间：

资金表现

• 初始资金：$50,000
• 最终权益：$51,095
• 总收益：约2.2%
• 最大回撤：控制在合理范围

交易统计

• 止盈次数：6次
• 止损次数：14次
• 胜率：30%

真实的结论

经过完整的回测验证，这个策略：

✅ 理论上可行的部分：

1. Beta对冲确实能降低单边风险
2. 价格比回归提供了套利空间
3. 止盈止损能保护利润

⚠️ 现实中的问题：

1. 收益不高：盈利仅为30%，3个月累计收益2.2%，远不是帖子里说的4倍收益
2. 开仓机会少：2%的阈值限制了开仓频率
3. 手续费成本：频繁开平仓会吃掉不少利润
4. 滑点风险：实盘可能比回测差
5. 极端行情：如果BTC和ETH同时暴涨/暴跌，对冲失效

🔍 可以优化的方向：

1. 多币种轮动：不只对冲ETH，可以加入SOL、BNB等
2. 动态阈值：根据波动率调整开仓阈值
3. 止损冷却：止损后禁止马上开仓
4. 波动率Delta对冲：除了价格Beta，还可以考虑波动率对冲
5. 资金管理：动态调整每次开仓的资金比例

写在最后：量化的意义

这就是量化交易的魅力所在：

从一个想法出发 → 写代码实现 → 回测验证 → 优化改进

知乎上那篇帖子的策略思路没问题，但魔鬼在细节里：

• 没有Beta对冲，就是赌方向
• 没有风控机制，就是裸奔
• 没有回测验证，就是YY

真正的量化交易，是把每一个想法都用数据验证，把每一个策略都用代码实现，把每一次交易都留下记录。

有想法，就要去验证。

代码已经放在文章末尾了，欢迎大家自己跑一跑，改一改，优化优化。

如果大家感兴趣，后面可以继续写：

• 基于波动率Delta的对冲策略
• 多币种轮动的实现
• 资金管理和风控优化

欢迎点赞、评论、催更！

📝文章源码（策略参数可在源码开头参数部分灵活设置，交易逻辑已进行优化）：双向Beta对冲策略

免责声明

本文仅供学习交流，不构成任何投资建议。

PS：币圈没有稳定暴富法，只有风险管理和持续优化。