Die Ressourcen sind geladen. Beförderung...
  1. Verdauung
  2. Original
  3. Arbeitsbereitschaft und Vorrang - Lernen Sie, wie man Umgebungsforschung und Analyse von Transaktionen nutzt

Arbeitsbereitschaft und Vorrang - Lernen Sie, wie man Umgebungsforschung und Analyse von Transaktionen nutzt

Schriftsteller:Die Erfinder quantifizieren - Kleine Träume, Erstellt: 2019-10-09 17:36:50, Aktualisiert: 2023-10-18 19:56:32

img

Arbeitsbereitschaft und Vorrang - Lernen Sie, wie man Umgebungsforschung und Analyse von Transaktionen nutzt

Der Begriff "Hedging" ist in der Quantitative-Trading- und Programmatic-Trading-Branche ein sehr grundlegendes Konzept. In der Quantitative-Trading-Branche von digitalen Währungen werden häufig folgende Hedging-Strategien verwendet: Futures-Hedging, Cross-Term-Hedging, Spot-Hedging, die im Wesentlichen für Differenz-Trading sind.

Klicken Sie auf "Research Environment" in der Quantified Control Center für die Erfinder und Sie springen auf die Seite des Tools:img

Hier habe ich diese Analyse direkt hochgeladen: Diese Analyse ist eine Analyse der Prozesse, die für eine Futures-Hedge-Opening-Platzierung bei Rücksichtszeiten durchgeführt werden, wobei die Futures-Börse für OKEX-Futures und für Quartalskontrakte handelt.quarterOKEX ist eine Währung, die von den Börsen in den USA und in den USA verkauft wird.BTC_USDTFür die Analyse des aktuellen Hedging-Betriebsprozesses können Sie sich die folgenden spezifischen Forschungsumgebungsdokumente ansehen, in denen zwei Versionen, eine Python- und eine JavaScript-Beschreibung, geschrieben sind.

  • Forschungsumgebung Python-Dateien

    from fmz import *
task = VCtx('''backtest
start: 2019-09-19 00:00:00
end: 2019-09-28 12:00:00
period: 15m
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD", "stocks":1}, {"eid":"OKEX","currency":"BTC_USDT","balance":10000,"stocks":0}]
''')
# 创建回测环境
import matplotlib.pyplot as plt
import numpy as np
# 导入画图的库 matplotlib 和 numpy 库
    exchanges[0].SetContractType("quarter")    # 第一个交易所对象OKEX期货（eid:Futures_OKCoin）调用设置当前合约的函数，设置为季度合约
initQuarterAcc = exchanges[0].GetAccount() # OKEX期货交易所初始时的账户信息，记录在变量initQuarterAcc
initQuarterAcc
    {'Balance': 0.0, 'FrozenBalance': 0.0, 'Stocks': 1.0, 'FrozenStocks': 0.0}
    initSpotAcc = exchanges[1].GetAccount()    # OKEX现货交易所初始时的账户信息，记录在变量initSpotAcc
initSpotAcc
    {'Balance': 10000.0, 'FrozenBalance': 0.0, 'Stocks': 0.0, 'FrozenStocks': 0.0}
    quarterTicker1 = exchanges[0].GetTicker()  # 获取期货交易所行情，记录在变量quarterTicker1
quarterTicker1
    {'Time': 1568851210000,
 'High': 10441.25002,
 'Low': 10441.25,
 'Sell': 10441.25002,
 'Buy': 10441.25,
 'Last': 10441.25001,
 'Volume': 1772.0,
 'OpenInterest': 0.0}
    spotTicker1 = exchanges[1].GetTicker()     # 获取现货交易所行情，记录在变量spotTicker1
spotTicker1
    {'Time': 1568851210000,
 'High': 10156.60000002,
 'Low': 10156.6,
 'Sell': 10156.60000002,
 'Buy': 10156.6,
 'Last': 10156.60000001,
 'Volume': 7.4443,
 'OpenInterest': 0.0}
    quarterTicker1.Buy - spotTicker1.Sell      # 期货做空，现货做多的差价
    284.64999997999985
    exchanges[0].SetDirection("sell")                       # 设置期货交易所，交易方向为做空
quarterId1 = exchanges[0].Sell(quarterTicker1.Buy, 10)  # 期货做空下单，下单量为10张合约，返回的订单ID记录在变量quarterId1
exchanges[0].GetOrder(quarterId1)                       # 查询期货订单ID为quarterId1的订单详情
    {'Id': 1,
 'Price': 10441.25,
 'Amount': 10.0,
 'DealAmount': 10.0,
 'AvgPrice': 10441.25,
 'Type': 1,
 'Offset': 0,
 'Status': 1,
 'ContractType': b'quarter'}
    spotAmount = 10 * 100 / quarterTicker1.Buy                 # 计算10张合约等值的币数，作为现货的下单量
spotId1 = exchanges[1].Buy(spotTicker1.Sell, spotAmount)   # 现货交易所下单
exchanges[1].GetOrder(spotId1)                             # 查询现货订单ID为spotId1的订单详情
    {'Id': 1,
 'Price': 10156.60000002,
 'Amount': 0.0957,
 'DealAmount': 0.0957,
 'AvgPrice': 10156.60000002,
 'Type': 0,
 'Offset': 0,
 'Status': 1,
 'ContractType': b'BTC_USDT_OKEX'}
    可以看到订单quarterId1、spotId1订单都完全成交，即对冲开仓完成。
    

    Sleep(1000 * 60 * 60 * 24 * 7)       # 持仓一段时间，等待差价变小平仓。
    等待时间过后，准备平仓。获取当前的行情quarterTicker2、spotTicker2并且打印。
期货交易所对象的交易方向设置为平空仓：exchanges[0].SetDirection("closesell")下单平仓。
打印平仓订单的详情，显示平仓订单完全成交，平仓完成。
    

    quarterTicker2 = exchanges[0].GetTicker()     # 获取当前期货交易所的行情，记录在变量quarterTicker2
quarterTicker2
    {'Time': 1569456010000,
 'High': 8497.20002,
 'Low': 8497.2,
 'Sell': 8497.20002,
 'Buy': 8497.2,
 'Last': 8497.20001,
 'Volume': 4311.0,
 'OpenInterest': 0.0}
    spotTicker2 = exchanges[1].GetTicker()       # 获取当前现货交易所的行情，记录在变量spotTicker2
spotTicker2
    {'Time': 1569456114600,
 'High': 8444.70000001,
 'Low': 8444.69999999,
 'Sell': 8444.70000001,
 'Buy': 8444.69999999,
 'Last': 8444.7,
 'Volume': 78.6273,
 'OpenInterest': 0.0}
    quarterTicker2.Sell - spotTicker2.Buy        # 期货空头仓位平仓，现货多头仓位平仓的差价
    52.5000200100003
    exchanges[0].SetDirection("closesell")                   # 设置期货交易所当前交易方向为平空仓
quarterId2 = exchanges[0].Buy(quarterTicker2.Sell, 10)   # 期货交易所下单平仓，并且记录下单ID，记录到变量quarterId2
exchanges[0].GetOrder(quarterId2)                        # 查询期货平仓订单详情
    {'Id': 2,
 'Price': 8497.20002,
 'Amount': 10.0,
 'DealAmount': 10.0,
 'AvgPrice': 8493.95335,
 'Type': 0,
 'Offset': 1,
 'Status': 1,
 'ContractType': b'quarter'}
    spotId2 = exchanges[1].Sell(spotTicker2.Buy, spotAmount) # 现货交易所下单平仓，并且记录下单ID，记录到变量spotId2
exchanges[1].GetOrder(spotId2)      # 查询现货平仓订单详情
    {'Id': 2,
 'Price': 8444.69999999,
 'Amount': 0.0957,
 'DealAmount': 0.0957,
 'AvgPrice': 8444.69999999,
 'Type': 1,
 'Offset': 0,
 'Status': 1,
 'ContractType': b'BTC_USDT_OKEX'}
    nowQuarterAcc = exchanges[0].GetAccount()   # 获取当前期货交易所账户信息，记录在变量nowQuarterAcc
nowQuarterAcc
    {'Balance': 0.0,
 'FrozenBalance': 0.0,
 'Stocks': 1.021786026184,
 'FrozenStocks': 0.0}
    nowSpotAcc = exchanges[1].GetAccount()      # 获取当前现货交易所账户信息，记录在变量nowSpotAcc
nowSpotAcc
    {'Balance': 9834.74705446,
 'FrozenBalance': 0.0,
 'Stocks': 0.0,
 'FrozenStocks': 0.0}
    通过对比最初账户和当前账户，计算出此次对冲操作的收益盈亏。
    

    diffStocks = abs(nowQuarterAcc.Stocks - initQuarterAcc.Stocks)
diffBalance = nowSpotAcc.Balance - initSpotAcc.Balance
if nowQuarterAcc.Stocks - initQuarterAcc.Stocks > 0 :
    print("收益：", diffStocks * spotTicker2.Buy + diffBalance)
else :
    print("收益：", diffBalance - diffStocks * spotTicker2.Buy)
    收益： 18.72350977580652

    下面我们看下为什么此次对冲是盈利的。我们可以看到画出的图表，期货价格是蓝色的线，现货价格是橙色的线，两个价格都是下降的，期货价格下降的比现货价格快。
    

    xQuarter = [1, 2]
yQuarter = [quarterTicker1.Buy, quarterTicker2.Sell]

xSpot = [1, 2]
ySpot = [spotTicker1.Sell, spotTicker2.Buy]
plt.plot(xQuarter, yQuarter, linewidth=5)
plt.plot(xSpot, ySpot, linewidth=5)
plt.show()
    <Figure size 432x288 with 1 Axes>
    我们再看下差价的变化情况，差价是从对冲开仓时的284（即期货做空，现货最多），到平仓时的52（期货空头持仓平仓，现货多仓平仓）。差价是从大到小。
    

    xDiff = [1, 2]
yDiff = [quarterTicker1.Buy - spotTicker1.Sell, quarterTicker2.Sell - spotTicker2.Buy]
plt.plot(xDiff, yDiff, linewidth=5)
plt.show()
    <Figure size 432x288 with 1 Axes>
    我们举个例子，a1为时刻1的期货价格，b1为时刻1的现货价格。a2为时刻2的期货价格，b2为时刻2的现货价格。
    

    只要a1-b1即时刻1的期货现货差价大于a2-b2即时刻2时的期货现货差价，就可以推出a1 - a2 > b1 - b2。
有三种情况：（期货现货持仓头寸规模相同）
    

      

    • 

      1、a1 - a2大于0，b1 - b2大于0
a1 - a2为期货盈利的差价，b1 - b2为现货亏损的差价（因为现货做多，开始买入的价格比卖出平仓的价格高，所以亏钱），但是期货盈利的大于现货亏损的。所以整体是盈利。这种情况对应的就是步骤In[8]中的图表情况。
      

      • 

    • 

      2、a1 - a2大于0，b1 - b2小于0
a1 - a2为期货盈利的差价，b1 - b2为现货盈利的差价（b1 - b2 小于0，说明b2大于b1，即开仓买入的价格低，卖出平仓的价格高，所以盈利）
      

      • 

    • 

      3、a1 - a2小于0，b1 - b2小于0
a1 - a2为期货亏损的差价，b1 - b2为现货盈利的差价由于a1 - a2 > b1 - b2，a1 - a2的绝对值小于b1 - b2的绝对值，现货的盈利大于期货的亏损。整体为盈利。
      

      • 

    

    不存在 a1 - a2小于0，b1 - b2大于0这种情况，因为已经限定了a1 - a2 > b1 - b2。同样如果a1 - a2等于0，由于a1 - a2 > b1 - b2限定，b1 - b2就一定是小于0的。所以只要是期货做空，现货做多的对冲方式，符合条件a1 - b1 > a2 - b2，的开仓平仓操作，即为盈利对冲。
    

    例如以下模型为其中一种情况：
    

    a1 = 10
b1 = 5
a2 = 11
b2 = 9

# a1 - b1 > a2 - b2 推出 ： a1 - a2 > b1 - b2

xA = [1, 2]
yA = [a1, a2]

xB = [1, 2]
yB = [b1, b2]
plt.plot(xA, yA, linewidth=5)
plt.plot(xB, yB, linewidth=5)
plt.show()
    <Figure size 432x288 with 1 Axes>

  • Umgebungsforschung JavaScript-Dateien

    Die Forschung unterstützt nicht nur Python, sondern auch JavaScript Hier ist ein Beispiel für eine JavaScript-Studienumgebung:

    // 导入需要的程序包, 在发明者 "策略编辑页面" 点击 "保存回测设置" 即可获取字符串配置, 转换为对象即可
var fmz = require("fmz")                           // 引入后自动导入 talib, TA, plot 库
var task = fmz.VCtx({
start: '2019-09-19 00:00:00',
end: '2019-09-28 12:00:00',
period: '15m',
exchanges: [{"eid":"Futures_OKCoin","currency":"BTC_USD","stocks":1},{"eid":"OKEX","currency":"BTC_USDT","balance":10000,"stocks":0}]
})
    exchanges[0].SetContractType("quarter")  // 第一个交易所对象OKEX期货（eid:Futures_OKCoin）调用设置当前合约的函数，设置为季度合约
var initQuarterAcc = exchanges[0].GetAccount()  // OKEX期货交易所初始时的账户信息，记录在变量initQuarterAcc
initQuarterAcc
    { Balance: 0, FrozenBalance: 0, Stocks: 1, FrozenStocks: 0 }
    var initSpotAcc = exchanges[1].GetAccount()     // OKEX现货交易所初始时的账户信息，记录在变量initSpotAcc
initSpotAcc
    { Balance: 10000, FrozenBalance: 0, Stocks: 0, FrozenStocks: 0 }
    var quarterTicker1 = exchanges[0].GetTicker()   // 获取期货交易所行情，记录在变量quarterTicker1
quarterTicker1
    { Time: 1568851210000,
  High: 10441.25002,
  Low: 10441.25,
  Sell: 10441.25002,
  Buy: 10441.25,
  Last: 10441.25001,
  Volume: 1772,
  OpenInterest: 0 }
    var spotTicker1 = exchanges[1].GetTicker()     // 获取现货交易所行情，记录在变量spotTicker1
spotTicker1
    { Time: 1568851210000,
  High: 10156.60000002,
  Low: 10156.6,
  Sell: 10156.60000002,
  Buy: 10156.6,
  Last: 10156.60000001,
  Volume: 7.4443,
  OpenInterest: 0 }
    quarterTicker1.Buy - spotTicker1.Sell         // 期货做空，现货做多的差价
    284.64999997999985
    exchanges[0].SetDirection("sell")             // 设置期货交易所，交易方向为做空
var quarterId1 = exchanges[0].Sell(quarterTicker1.Buy, 10)  // 期货做空下单，下单量为10张合约，返回的订单ID记录在变量quarterId1
exchanges[0].GetOrder(quarterId1)                           // 查询期货订单ID为quarterId1的订单详情
    { Id: 1,
  Price: 10441.25,
  Amount: 10,
  DealAmount: 10,
  AvgPrice: 10441.25,
  Type: 1,
  Offset: 0,
  Status: 1,
  ContractType: 'quarter' }
    var spotAmount = 10 * 100 / quarterTicker1.Buy                  // 计算10张合约等值的币数，作为现货的下单量
var spotId1 = exchanges[1].Buy(spotTicker1.Sell, spotAmount)    // 现货交易所下单
exchanges[1].GetOrder(spotId1)                                  // 查询现货订单ID为spotId1的订单详情
    { Id: 1,
  Price: 10156.60000002,
  Amount: 0.0957,
  DealAmount: 0.0957,
  AvgPrice: 10156.60000002,
  Type: 0,
  Offset: 0,
  Status: 1,
  ContractType: 'BTC_USDT_OKEX' }
    可以看到订单quarterId1、spotId1订单都完全成交，即对冲开仓完成。
    

    Sleep(1000 * 60 * 60 * 24 * 7)            // 持仓一段时间，等待差价变小平仓。
    等待时间过后，准备平仓。获取当前的行情quarterTicker2、spotTicker2并且打印。
期货交易所对象的交易方向设置为平空仓：exchanges[0].SetDirection(&#34;closesell&#34;)下单平仓。
打印平仓订单的详情，显示平仓订单完全成交，平仓完成。
    

    var quarterTicker2 = exchanges[0].GetTicker()    // 获取当前期货交易所的行情，记录在变量quarterTicker2
quarterTicker2
    { Time: 1569456010000,
  High: 8497.20002,
  Low: 8497.2,
  Sell: 8497.20002,
  Buy: 8497.2,
  Last: 8497.20001,
  Volume: 4311,
  OpenInterest: 0 }
    var spotTicker2 = exchanges[1].GetTicker()       // 获取当前现货交易所的行情，记录在变量spotTicker2
spotTicker2
    { Time: 1569456114600,
  High: 8444.70000001,
  Low: 8444.69999999,
  Sell: 8444.70000001,
  Buy: 8444.69999999,
  Last: 8444.7,
  Volume: 78.6273,
  OpenInterest: 0 }
    quarterTicker2.Sell - spotTicker2.Buy            // 期货空头仓位平仓，现货多头仓位平仓的差价
    52.5000200100003
    exchanges[0].SetDirection("closesell")           // 设置期货交易所当前交易方向为平空仓
var quarterId2 = exchanges[0].Buy(quarterTicker2.Sell, 10)       // 期货交易所下单平仓，并且记录下单ID，记录到变量quarterId2
exchanges[0].GetOrder(quarterId2)                                // 查询期货平仓订单详情
    { Id: 2,
  Price: 8497.20002,
  Amount: 10,
  DealAmount: 10,
  AvgPrice: 8493.95335,
  Type: 0,
  Offset: 1,
  Status: 1,
  ContractType: 'quarter' }
    var spotId2 = exchanges[1].Sell(spotTicker2.Buy, spotAmount)     // 现货交易所下单平仓，并且记录下单ID，记录到变量spotId2
exchanges[1].GetOrder(spotId2)                                   // 查询现货平仓订单详情
    { Id: 2,
  Price: 8444.69999999,
  Amount: 0.0957,
  DealAmount: 0.0957,
  AvgPrice: 8444.69999999,
  Type: 1,
  Offset: 0,
  Status: 1,
  ContractType: 'BTC_USDT_OKEX' }
    var nowQuarterAcc = exchanges[0].GetAccount()     // 获取当前期货交易所账户信息，记录在变量nowQuarterAcc
nowQuarterAcc                                     
    { Balance: 0,
  FrozenBalance: 0,
  Stocks: 1.021786026184,
  FrozenStocks: 0 }
    var nowSpotAcc = exchanges[1].GetAccount()        // 获取当前现货交易所账户信息，记录在变量nowSpotAcc
nowSpotAcc
    { Balance: 9834.74705446,
  FrozenBalance: 0,
  Stocks: 0,
  FrozenStocks: 0 }
    通过对比最初账户和当前账户，计算出此次对冲操作的收益盈亏。
    

    var diffStocks = Math.abs(nowQuarterAcc.Stocks - initQuarterAcc.Stocks)
var diffBalance = nowSpotAcc.Balance - initSpotAcc.Balance
if (nowQuarterAcc.Stocks - initQuarterAcc.Stocks > 0) {
    console.log("收益：", diffStocks * spotTicker2.Buy + diffBalance)
} else {
    console.log("收益：", diffBalance - diffStocks * spotTicker2.Buy)
}
    收益： 18.72350977580652

    下面我们看下为什么此次对冲是盈利的。我们可以看到画出的图表，期货价格是蓝色的线，现货价格是橙色的线，两个价格都是下降的，期货价格下降的比现货价格快。
    

    var objQuarter = {
    "index" : [1, 2],                                          // 索引index 为1 即第一个时刻，开仓时刻，2为平仓时刻。
    "arrPrice" : [quarterTicker1.Buy, quarterTicker2.Sell],
}
var objSpot = {
    "index" : [1, 2],
    "arrPrice" : [spotTicker1.Sell, spotTicker2.Buy],
}
plot([{name: 'quarter', x: objQuarter.index, y: objQuarter.arrPrice}, {name: 'spot', x: objSpot.index, y: objSpot.arrPrice}])
    我们再看下差价的变化情况，差价是从对冲开仓时的284（即期货做空，现货最多），到平仓时的52（期货空头持仓平仓，现货多仓平仓）。差价是从大到小。
    

    var arrDiffPrice = [quarterTicker1.Buy - spotTicker1.Sell, quarterTicker2.Sell - spotTicker2.Buy]
plot(arrDiffPrice)
    我们举个例子，a1为时刻1的期货价格，b1为时刻1的现货价格。a2为时刻2的期货价格，b2为时刻2的现货价格。
    

    只要a1-b1即时刻1的期货现货差价大于a2-b2即时刻2时的期货现货差价，就可以推出a1 - a2 > b1 - b2。
有三种情况：（期货现货持仓头寸规模相同）
    

      

    • 

      1、a1 - a2大于0，b1 - b2大于0
a1 - a2为期货盈利的差价，b1 - b2为现货亏损的差价（因为现货做多，开始买入的价格比卖出平仓的价格高，所以亏钱），但是期货盈利的大于现货亏损的。所以整体是盈利。这种情况对应的就是步骤In[8]中的图表情况。
      

      • 

    • 

      2、a1 - a2大于0，b1 - b2小于0
a1 - a2为期货盈利的差价，b1 - b2为现货盈利的差价（b1 - b2 小于0，说明b2大于b1，即开仓买入的价格低，卖出平仓的价格高，所以盈利）
      

      • 

    • 

      3、a1 - a2小于0，b1 - b2小于0
a1 - a2为期货亏损的差价，b1 - b2为现货盈利的差价由于a1 - a2 > b1 - b2，a1 - a2的绝对值小于b1 - b2的绝对值，现货的盈利大于期货的亏损。整体为盈利。
      

      • 

    

    不存在 a1 - a2小于0，b1 - b2大于0这种情况，因为已经限定了a1 - a2 > b1 - b2。同样如果a1 - a2等于0，由于a1 - a2 > b1 - b2限定，b1 - b2就一定是小于0的。所以只要是期货做空，现货做多的对冲方式，符合条件a1 - b1 > a2 - b2，的开仓平仓操作，即为盈利对冲。
    

    例如以下模型为其中一种情况：
    

    var a1 = 10
var b1 = 5
var a2 = 11
var b2 = 9

// a1 - b1 > a2 - b2 推出 ： a1 - a2 > b1 - b2

var objA = {
    "index" : [1, 2],
    "arrPrice" : [a1, a2],
}
var objB = {
    "index" : [1, 2],
    "arrPrice" : [b1, b2],
}
plot([{name : "a", x : objA.index, y : objA.arrPrice}, {name : "b", x : objB.index, y : objB.arrPrice}])

Ich bin der Meinung, dass es eine gute Idee ist, das zu versuchen.

Verwandt
Mehr

FlotoxIch danke Ihnen.

2019 FMZ - Alle Rechte vorbehalten