संसाधन लोड हो रहा है... लोड करना...
  1. पचाना
  2. मूल
  3. काम करने की इच्छा और उसके लिए सबसे पहले - अध्ययन के लिए पर्यावरण विश्लेषण के लिए व्यापार के सिद्धांतों का उपयोग करना सीखें

काम करने की इच्छा और उसके लिए सबसे पहले - अध्ययन के लिए पर्यावरण विश्लेषण के लिए व्यापार के सिद्धांतों का उपयोग करना सीखें

लेखक:आविष्कारक मात्रा - छोटे सपने, बनाया गयाः 2019-10-09 17:36:50, अद्यतन किया गयाः 2023-10-18 19:56:32

img

काम करने की इच्छा और उसके लिए सबसे पहले - अध्ययन के लिए पर्यावरण विश्लेषण के लिए व्यापार के सिद्धांतों का उपयोग करना सीखें

क्वांटिफाइड ट्रेडिंग, प्रोग्रामेटिक ट्रेडिंग के क्षेत्र में हेजिंग हेजिंग शब्द को एक बहुत ही बुनियादी अवधारणा कहा जा सकता है, डिजिटल मुद्राओं के क्वांटिफाइड ट्रेडिंग में, अक्सर उपयोग की जाने वाली हेजिंग रणनीतियां हैंः वायदा हेजिंग, ओवरफॉर्म हेजिंग, नकदी हेजिंग, जो मूल रूप से अंतर के लिए व्यापार करते हैं। हो सकता है कि हेजिंग के बारे में बात करें।

खोजकर्ताओं के लिए क्वांटिफाइड कंट्रोल सेंटर में, "अध्ययन वातावरण" पर क्लिक करें और इस उपकरण के पृष्ठ पर जाएंःimg

यहां मैंने इस विश्लेषण को सीधे अपलोड किया हैः यह विश्लेषण दस्तावेज पुनर्मूल्यांकन के समय एक फ्यूचर्स हेजिंग स्टॉक के लिए एक प्रक्रिया विश्लेषण है, फ्यूचर्स एक्सचेंज ओकेएक्स फ्यूचर्स, अनुबंध प्रति तिमाही अनुबंधquarterओकेएक्स मुद्राओं के लिए एक्सचेंजों में लेन-देन किया जाता है, और लेन-देन के लिए जोड़े को ओकेएक्स मुद्राओं के रूप में संदर्भित किया जाता है।BTC_USDT, विश्लेषण के लिए वर्तमान हेज ऑपरेटिंग प्रक्रियाओं, आप नीचे दिए गए विशिष्ट अनुसंधान पर्यावरण दस्तावेज़ देख सकते हैं, जिसमें दो संस्करण लिखे गए हैं, एक पायथन भाषा का वर्णन और एक जावास्क्रिप्ट भाषा का वर्णन।

  • खोज वातावरण पायथन भाषा के दस्तावेज़

    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>

  • जावास्क्रिप्ट भाषा के दस्तावेज़

    अनुसंधान वातावरण Python के अलावा जावास्क्रिप्ट का भी समर्थन करता है यहाँ मैं जावास्क्रिप्ट के लिए एक उदाहरण भी देता हूँः

    // 导入需要的程序包, 在发明者 "策略编辑页面" 点击 "保存回测设置" 即可获取字符串配置, 转换为对象即可
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}])

दोस्तों, जल्दी करो और कोशिश करो!

संबंधित
अधिक

फ्लोटॉक्सधन्यवाद ड्रीमसम

2019 FMZ - सभी अधिकार सुरक्षित