[बाइनेंस चैम्पियनशिप] बाइनेंस वितरण अनुबंध रणनीति 3 - तितली हेजिंग

हाल ही में, बाइनेंस वायदा ने दूसरी बाइनेंस चैम्पियनशिप (पतेःhttps://www.binancezh.com/cn/futures/activity/anniversary-competition/129-38599440) आधिकारिक एफएमजेड क्वांट प्लेटफॉर्म ने भी एक टीम का आयोजन किया है, जिसे सीधे एफएमजेड क्वांट की खोज करके पाया जा सकता है। वर्तमान में, 100 से अधिक लोग हैं। हमसे जुड़ने के लिए आपका स्वागत है। उसके बाद, आप टीम लीडर का वीचैट जोड़ सकते हैंः fmz_zhangchao, उत्तर Binance, और हम आपको वीचैट समूह में शामिल होने के लिए आमंत्रित करेंगे।

बिनेंस चैंपियनशिप के लिए तैयार की गई रणनीति वितरण अनुबंध की तितली हेजिंग है। यह लेख रणनीति की शोध रिपोर्ट है। ध्यान देंः रणनीतियाँ केवल संदर्भ के लिए हैं। आप इस आधार पर अनुकूलन के लिए अपने स्वयं के विचारों को आगे रख सकते हैं। आप साझा करने के लिए भी स्वागत करते हैं। रिपोर्ट का उपयोग सीधे एफएमजेड वेबसाइट के अनुसंधान वातावरण में किया जा सकता है (डाउनलोड करने के लिए ऊपरी दाएं कोने पर क्लिक करें, और विश्लेषण में अपलोड करें) ।

1. रणनीतिक कारण

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

2. रणनीति के सिद्धांत

बिनेंस मुद्रा मानक अनुबंध, जैसे BTC और ETH, एक ही समय में तीन अनुबंध हैं, अर्थात्, अनन्त BTCUSD_ PERP, BTCUSDचालू तिमाही के 200925 में, BTCUSD201225 की अगली तिमाही के. स्थायी अनुबंध स्पॉट के रूप में इस्तेमाल किया जा सकता है. आम तौर पर, दो अनुबंधों को हेज करने के लिए तीन मूल्य अंतर हैंः वर्तमान तिमाही-स्थायी, अगली तिमाही-स्थायी, और अगली तिमाही-वर्तमान तिमाही. तितली मध्यस्थता के लिए तीन अनुबंधों की आवश्यकता होती है. अंतर है (अगली तिमाही - वर्तमान तिमाही) - (वर्तमान तिमाही - स्थायी), यानी अंतर=अगली तिमाही + स्थायी - 2 * वर्तमान तिमाही. मूल्य अंतर को लंबा करने के लिए, आपको अगली तिमाही और स्थायी अनुबंधों के लिए एक लंबी स्थिति अनुबंध खोलने की आवश्यकता है, और वर्तमान तिमाही के लिए दो अनुबंधों को छोटा करना होगा।

3. हेजिंग स्पेस

मैंने 14 अगस्त से 14 सितंबर तक बिनेंस के 5 मिनट के-लाइन के डेटा को क्रॉल किया है, जिसे सीधे पढ़ा जा सकता है (समय अंतर के कारण, दिखाया गया समय अंतर 8h है) ।

[4] मेंः

# Libraries to be imported
import pandas as pd
import requests
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
import time
%matplotlib inline

[12] मेंः

#Read the data, you can also upload the data to the FMZ forum, which can be referenced in the "Analyze" directly
df = pd.read_csv('https://www.fmz.com/upload/asset/1420b2081ecd122522d.csv',index_col = 0)
df.index = pd.to_datetime(df.index)
df.tail(3)

बाहर[12]:

सबसे पहले, आइए बिटकॉइन अनुबंधों के बीच मूल्य अंतर पर एक नज़र डालें। 17 अगस्त को, बिटकॉइन की कीमत तेजी से 500u तक बढ़ी। आम तौर पर, स्पॉट मूल्य की तुलना में वितरित अनुबंध प्रीमियम पर था, और स्पॉट मूल्य बढ़ गया। भविष्य के लिए उम्मीद अधिक आशावादी होगी। अवैतनिक अनुबंध और अनंतता के बीच मूल्य अंतर बड़ा हो जाएगा। उदाहरण के लिए, अगली तिमाही और अनंतता के बीच मूल्य अंतर 700u होगा। सितंबर में बिटकॉइन की कीमत में कमी के साथ, लोगों की उम्मीदें तेजी से बिगड़ेंगी, अगली तिमाही और अनंतता के बीच मूल्य अंतर लगभग 150u तक गिर गया, और वर्तमान तिमाही और अनंतता के बीच लगभग कोई मूल्य अंतर नहीं था। यदि अगली तिमाही और अनंतता के बीच हेजिंग की गई थी, तो केवल लंबी अवधि की कीमत की वापसी की जा सकती थी। यदि 400-600 अगस्त के बीच अंतर को अब एक राज्य में निष्पादित करने का फैसला किया गया था, तो यह स्पष्ट रूप से एक लॉक में है।

[18] मेंः

#Perpetual price
df['BTCUSD_PERP'].dropna().plot(figsize=(15,6),grid=True);

बाहर[18]:

[15] मेंः

# Price difference of next quarter - perpetual
(df['BTCUSD_201225']-df['BTCUSD_PERP']).dropna().plot(figsize=(15,6),grid=True);

बाहर[15]:

[16] मेंः

# Price difference of current quarter - perpetual
(df['BTCUSD_200925']-df['BTCUSD_PERP']).dropna().plot(figsize=(15,6),grid=True);

बाहर[16]:

[17] मेंः

# Price difference of next quarter - current quarter
(df['BTCUSD_201225']-df['BTCUSD_200925']).dropna().plot(figsize=(15,6),grid=True);

बाहर[17]:

तो इस समय मूल्य अंतर कैसे बदलता है? जैसा कि नीचे दिए गए चित्र से देखा जा सकता है, हालिया मूल्य अंतर लंबे समय तक 100-200u पर स्थिर रहा है। सितंबर की शुरुआत में तेज गिरावट ने भी बहुत अधिक प्रभाव नहीं डाला, जिससे हमें बार-बार मध्यस्थता के लिए बहुत अधिक जगह मिली। वर्तमान में, यदि मूल्य अंतर 100u तक गिरता है, तो मैन्युअल रूप से लंबा जाना ठीक है।

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

[19] मेंः

#（next quarter - current quarter）-（current quarter - perpetual）
(df['BTCUSD_201225']-df['BTCUSD_200925']-(df['BTCUSD_200925']-df['BTCUSD_PERP'])).dropna().plot(figsize=(15,6),grid=True);

बाहर[19]:

[22] मेंः

#The price difference of ETH
(df['ETHUSD_201225']+df['ETHUSD_PERP']-2*df['ETHUSD_200925']).dropna().plot(figsize=(15,6),grid=True);

बाहर[22]:

4. रणनीति बैकटेस्ट

समय बचाने के लिए (बस आलस्य), बैकटेस्ट अभी भी पिछली बाइनेंस चैम्पियनशिप रणनीति के यूएसडीटी मानक इंजन का उपयोग करता है। हालांकि कुछ त्रुटियां हो सकती हैं, यह समस्या की व्याख्या भी कर सकती है। बैकटेस्टिंग इंजन को इस रिपोर्ट के अंत में रखा गया है। कोड चलाते समय, आपको लेख का अंत देखना चाहिए। मुद्रा मानक रणनीति हेजिंग पर विचार कर सकती है यदि आप यूएसडीटी कमाना चाहते हैं, और यह जटिल नहीं है।

मूल्य अंतर की मध्य रेखा को ईएमए द्वारा ट्रैक किया जाता है, और स्थिति को ग्रिड द्वारा नियंत्रित किया जाता है, अर्थात, हर बार जब अंतर खोला जाता है (जैसे 30), तो एन शेयरों को शॉर्ट करें, और इसके विपरीत। यदि मूल्य अंतर की मध्य रेखा 100u है, जब मूल्य अंतर 90 है, तो 3 शेयरों को शॉर्ट करें, और मूल्य अंतर 60 हो जाता है, एक शेयर बंद करें। ग्रिड का आकार एक महत्वपूर्ण पैरामीटर है।

निम्नलिखित विशिष्ट BTC और ETH बैकटेस्टिंग कोड और परिणाम हैं। प्रदर्शन अपेक्षाओं के अनुरूप है। क्योंकि ETH और LINK में अधिक अस्थिरता है और मूल्य अंतर अधिक स्थिर है, प्रदर्शन बेहतर है। ध्यान दें कि यहां सेवा शुल्क 0.02%, और बिनेंस में डिफ़ॉल्ट वीआईपी0 टेकर सेवा शुल्क 0.04% है। सेवा शुल्क बहुत महत्वपूर्ण है, और निम्नलिखित अध्याय इसका विश्लेषण करेंगे।

[39] मेंः

trade_symbols = ['BTCUSD_201225', 'BTCUSD_200925', 'BTCUSD_PERP']
account = []
diff = df['BTCUSD_201225']+df['BTCUSD_PERP']-2*df['BTCUSD_200925']
diff_mean = diff.ewm(alpha=0.001).mean()
e = Exchange(trade_symbols,initial_balance=10000,taker_fee=0.0002)
for row in df[trade_symbols].dropna().iterrows():
    date = row[0]
    prices = row[1]
    e.Update(date, trade_symbols, prices)
    account.append([e.account['USDT']['margin'],e.account['USDT']['realised_profit']+e.account['USDT']['unrealised_profit']])
    aim_amount = -round((diff[date] - diff_mean[date])/30,1)
    now_amount = e.account['BTCUSD_PERP']['amount']
    if aim_amount - now_amount < -1:
        trade_amount = now_amount - aim_amount
        e.Buy('BTCUSD_200925',prices['BTCUSD_200925'],2*trade_amount)
        e.Sell('BTCUSD_201225',prices['BTCUSD_201225'],trade_amount)
        e.Sell('BTCUSD_PERP',prices['BTCUSD_PERP'],trade_amount)
    if aim_amount - now_amount > 1:
        trade_amount = aim_amount - now_amount
        e.Sell('BTCUSD_200925',prices['BTCUSD_200925'],2*trade_amount)
        e.Buy('BTCUSD_201225',prices['BTCUSD_201225'],trade_amount)
        e.Buy('BTCUSD_PERP',prices['BTCUSD_PERP'],trade_amount)
    
e.df = pd.DataFrame(index=df[trade_symbols].dropna().index,columns=['margin','profit'],data=account)
e.df['profit'].plot(figsize=(15,6),grid=True);

बाहर[39]:

[59] मेंः

symbol = 'ETH'
trade_symbols = [symbol+'USD_201225', symbol+'USD_200925', symbol+'USD_PERP']
fee = 0.0002
account = []
diff = df[trade_symbols[0]]+df[trade_symbols[2]]-2*df[trade_symbols[1]]
diff_mean = diff.ewm(alpha=0.001).mean()
e = Exchange(trade_symbols,initial_balance=10000,taker_fee=fee)
for row in df[trade_symbols].dropna().iloc[30:].iterrows():
    date = row[0]
    prices = row[1]
    e.Update(date, trade_symbols, prices)
    account.append([e.account['USDT']['margin'],e.account['USDT']['realised_profit']+e.account['USDT']['unrealised_profit']])
    aim_amount = -round((diff[date] - diff_mean[date])/(15*prices[trade_symbols[2]]*fee),1)
    now_amount = e.account[trade_symbols[2]]['amount']
    if aim_amount - now_amount < -1:
        trade_amount = 1
        e.Buy(trade_symbols[1],prices[trade_symbols[1]],2*trade_amount)
        e.Sell(trade_symbols[0],prices[trade_symbols[0]],trade_amount)
        e.Sell(trade_symbols[2],prices[trade_symbols[2]],trade_amount)
    if aim_amount - now_amount > 1:
        trade_amount = 1
        e.Sell(trade_symbols[1],prices[trade_symbols[1]],2*trade_amount)
        e.Buy(trade_symbols[0],prices[trade_symbols[0]],trade_amount)
        e.Buy(trade_symbols[2],prices[trade_symbols[2]],trade_amount)
e.df = pd.DataFrame(index=df[trade_symbols].dropna().iloc[30:].index,columns=['margin','profit'],data=account)
e.df['profit'].plot(figsize=(15,6),grid=True);

बाहर[59]:

[60] मेंः

symbol = 'LINK'
trade_symbols = [symbol+'USD_201225', symbol+'USD_200925', symbol+'USD_PERP']
fee = 0.0002
account = []
diff = df[trade_symbols[0]]+df[trade_symbols[2]]-2*df[trade_symbols[1]]
diff_mean = diff.ewm(alpha=0.001).mean()
e = Exchange(trade_symbols,initial_balance=10000,taker_fee=fee)
for row in df[trade_symbols].dropna().iloc[30:].iterrows():
    date = row[0]
    prices = row[1]
    e.Update(date, trade_symbols, prices)
    account.append([e.account['USDT']['margin'],e.account['USDT']['realised_profit']+e.account['USDT']['unrealised_profit']])
    aim_amount = -round((diff[date] - diff_mean[date])/(15*prices[trade_symbols[2]]*fee),1)
    now_amount = e.account[trade_symbols[2]]['amount']
    if aim_amount - now_amount < -1:
        trade_amount = 1
        e.Buy(trade_symbols[1],prices[trade_symbols[1]],2*trade_amount)
        e.Sell(trade_symbols[0],prices[trade_symbols[0]],trade_amount)
        e.Sell(trade_symbols[2],prices[trade_symbols[2]],trade_amount)
    if aim_amount - now_amount > 1:
        trade_amount = 1
        e.Sell(trade_symbols[1],prices[trade_symbols[1]],2*trade_amount)
        e.Buy(trade_symbols[0],prices[trade_symbols[0]],trade_amount)
        e.Buy(trade_symbols[2],prices[trade_symbols[2]],trade_amount)
e.df = pd.DataFrame(index=df[trade_symbols].dropna().iloc[30:].index,columns=['margin','profit'],data=account)
e.df['profit'].plot(figsize=(15,6),grid=True);

बाहर[60]:

5.कमिसन संवेदनशीलता

चूंकि 3 अनुबंधों को एक ही समय में संचालित करने की आवश्यकता होती है, इसलिए खुलने के बाद स्थिति को बंद करने के लिए 8 सेवा शुल्क की आवश्यकता होती है, इसलिए सेवा शुल्क की रणनीति पर बहुत प्रभाव पड़ता है। यदि 0.01% का सेवा शुल्क है, तो मूल्य अंतर ग्रिड के बीच का अंतर और कम हो सकता है। BTC के बैकटेस्टिंग के परिणाम निम्नलिखित चित्र में दिखाए गए हैंः

यदि कमीशन 0.03% है, तो बीटीसी बैकटेस्ट के परिणाम इस प्रकार हैं:

ईटीएच के बैकटेस्ट परिणाम:

नए पंजीकृत उपयोगकर्ताओं के लिए वीआईपी0 की टेकर दर 0.0004 है, आमंत्रित होने के पहले महीने में 10% कम हो जाएगी, 30% वापस कर दी जाएगी, और बीएनबी खपत के लिए 10% कम हो जाएगी। इस प्रकार, अंतिम हैंडलिंग शुल्क 0.0002268 है। बिनेंस डिलीवरी अनुबंध की हालिया बड़ी लेनदेन राशि के लिए भी एक प्रत्यक्ष पुरस्कार होगा। इसके अलावा, बिल का एक हिस्सा रखा जा सकता है और बिल का एक हिस्सा लिया जा सकता है, और अंतिम व्यापक दर 0.02 तक कम हो सकती है। इसके अलावा, एफएमजेड अधिकारी बिनेंस के साथ सेवा शुल्क छूट के मुद्दे पर भी चर्चा कर रहे हैं। आप इसका इंतजार कर सकते हैं।

सारांश

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

[23] मेंः

class Exchange:
    
    def __init__(self, trade_symbols, leverage=20, maker_fee=0.0002,taker_fee=0.0004,log='',initial_balance=10000):
        self.initial_balance = initial_balance #Initial assets
        self.taker_fee = taker_fee
        self.maker_fee = maker_fee
        self.leverage = leverage
        self.trade_symbols = trade_symbols
        self.date = ''
        self.log = log
        self.df = pd.DataFrame()
        self.account = {'USDT':{'realised_profit':0, 'margin':0, 'unrealised_profit':0, 
                                'total':initial_balance, 'leverage':0, 'fee':0,'maker_fee':0,'taker_fee':0}}
        for symbol in trade_symbols:
            self.account[symbol] = {'amount':0, 'hold_price':0, 'value':0, 'price':0, 'realised_profit':0,
                                    'margin':0, 'unrealised_profit':0,'fee':0}
            
    def Trade(self, symbol, direction, price, amount, msg='', maker=True):
        
        if (self.date and symbol == self.log) or self.log == 'all':
            print('%-26s%-15s%-5s%-10.8s%-8.6s %s'%(str(self.date)[:24], symbol, 'buy' if direction == 1 else 'sell', price, amount, msg))

        cover_amount = 0 if direction*self.account[symbol]['amount'] >=0 else min(abs(self.account[symbol]['amount']), amount)
        open_amount = amount - cover_amount
        if maker:
            self.account['USDT']['realised_profit'] -= price*amount*self.maker_fee #Deduct service charge
            self.account['USDT']['maker_fee'] += price*amount*self.maker_fee
            self.account['USDT']['fee'] += price*amount*self.maker_fee
            self.account[symbol]['fee'] += price*amount*self.maker_fee
        else:
            self.account['USDT']['realised_profit'] -= price*amount*self.taker_fee #Deduct service charge
            self.account['USDT']['taker_fee'] += price*amount*self.taker_fee
            self.account['USDT']['fee'] += price*amount*self.taker_fee
            self.account[symbol]['fee'] += price*amount*self.taker_fee

        
        
        if cover_amount > 0: #Close the position first
            self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #Profit
            self.account['USDT']['margin'] -= cover_amount*self.account[symbol]['hold_price']/self.leverage #Release margin
            
            self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
            self.account[symbol]['amount'] -= -direction*cover_amount
            self.account[symbol]['margin'] -=  cover_amount*self.account[symbol]['hold_price']/self.leverage
            self.account[symbol]['hold_price'] = 0 if self.account[symbol]['amount'] == 0 else self.account[symbol]['hold_price']
            
        if open_amount > 0:
            total_cost = self.account[symbol]['hold_price']*direction*self.account[symbol]['amount'] + price*open_amount
            total_amount = direction*self.account[symbol]['amount']+open_amount
            
            self.account['USDT']['margin'] +=  open_amount*price/self.leverage            
            self.account[symbol]['hold_price'] = total_cost/total_amount
            self.account[symbol]['amount'] += direction*open_amount
            self.account[symbol]['margin'] +=  open_amount*price/self.leverage
            
        self.account[symbol]['unrealised_profit'] = (price - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
        self.account[symbol]['price'] = price
        self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*price
        
    
    def Buy(self, symbol, price, amount, msg='', maker=False):
        self.Trade(symbol, 1, price, amount, msg, maker)
        
    def Sell(self, symbol, price, amount, msg='', maker=False):
        self.Trade(symbol, -1, price, amount, msg,maker)
        

    def Update(self, date, symbols, close_price): #Update the assets
        self.date = date
        self.close = close_price
        self.account['USDT']['unrealised_profit'] = 0
        for symbol in symbols:
            self.account[symbol]['unrealised_profit'] = (close_price[symbol] - self.account[symbol]['hold_price'])*self.account[symbol]['amount']
            self.account[symbol]['price'] = close_price[symbol]
            self.account[symbol]['value'] = abs(self.account[symbol]['amount'])*close_price[symbol]
            
            self.account['USDT']['unrealised_profit'] += self.account[symbol]['unrealised_profit']
        self.account['USDT']['total'] = round(self.account['USDT']['realised_profit'] + self.initial_balance + self.account['USDT']['unrealised_profit'],6)
        self.account['USDT']['leverage'] = round(self.account['USDT']['margin']*self.leverage/self.account['USDT']['total'],4)

[ ] मेंः