बिनेंस फ्यूचर्स मल्टी-करेंसी हेजिंग रणनीति भाग 4 पर शोध

बिनेंस वायदा बहु मुद्रा प्रतिभूति रणनीति की हालिया समीक्षा और मिनट स्तर के के-लाइन बैकटेस्ट परिणाम

बिनेंस की बहु-मुद्रा हेजिंग रणनीति पर तीन शोध रिपोर्ट प्रकाशित की गई हैं, यहाँ चौथा है। पहले तीन लेखों का संबंध, यदि आपने इसे नहीं पढ़ा है, तो आपको इसे फिर से पढ़ना चाहिए, आप रणनीति के गठन के विचार, विशिष्ट मापदंडों की स्थापना और रणनीति तर्क को समझ सकते हैं।

बाइनेंस फ्यूचर्स मल्टी-करेंसी हेजिंग रणनीति पर शोध भाग 1:https://www.fmz.com/digest-topic/5584

बिनेंस फ्यूचर्स मल्टी-करेंसी हेजिंग रणनीति भाग 2 पर शोधःhttps://www.fmz.com/digest-topic/5588

बाइनेंस फ्यूचर्स बहु-मुद्रा हेजिंग रणनीति भाग 3 पर शोधःhttps://www.fmz.com/digest-topic/5605

यह लेख हाल के सप्ताह की वास्तविक बाजार स्थिति की समीक्षा करने और लाभ और हानि का सारांश देने के लिए है। पिछले दो महीनों के बिनेंस फ्यूचर्स मिनट के लाइन डेटा को क्रॉल करने के बाद, मूल 1h K लाइन बैकटेस्ट परिणामों को अपडेट किया जा सकता है, जो कुछ पैरामीटर सेटिंग्स के अर्थ को बेहतर ढंग से समझा सकता है।

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

symbols = ['BTC','ETH', 'BCH', 'XRP', 'EOS', 'LTC', 'TRX', 'ETC', 'LINK', 'XLM', 'ADA', 'XMR', 'DASH', 'ZEC', 'XTZ', 'BNB', 'ATOM', 'ONT', 'IOTA', 'BAT', 'VET', 'NEO', 'QTUM', 'IOST']

मिनट स्तर के K लाइन डेटा

21 फरवरी से 15 अप्रैल दोपहर दो बजे के आंकड़े, कुल 77160 * 24, जो हमारे बैकटेस्ट गति में काफी कमी आई, बैकटेस्ट इंजन पर्याप्त कुशल नहीं है, आप इसे स्वयं अनुकूलित कर सकते हैं। भविष्य में, मैं नियमित रूप से नवीनतम डेटा ट्रैक करूंगा।

price_usdt = pd.read_csv('https://www.fmz.com/upload/asset/2b1fa7ab641385067ad.csv',index_col = 0)
price_usdt.shape

(77160, 24)

price_usdt.index = pd.to_datetime(price_usdt.index,unit='ms')
price_usdt_norm = price_usdt/price_usdt.fillna(method='bfill').iloc[0,]
price_usdt_btc = price_usdt.divide(price_usdt['BTC'],axis=0)
price_usdt_btc_norm = price_usdt_btc/price_usdt_btc.fillna(method='bfill').iloc[0,]

class Exchange:
    
    def __init__(self, trade_symbols, leverage=20, commission=0.00005,  initial_balance=10000, log=False):
        self.initial_balance = initial_balance # Initial asset
        self.commission = commission
        self.leverage = leverage
        self.trade_symbols = trade_symbols
        self.date = ''
        self.log = log
        self.df = pd.DataFrame(columns=['margin','total','leverage','realised_profit','unrealised_profit'])
        self.account = {'USDT':{'realised_profit':0, 'margin':0, 'unrealised_profit':0, 'total':initial_balance, 'leverage':0, '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=''):
        if self.date and self.log:
            print('%-20s%-5s%-5s%-10.8s%-8.6s %s'%(str(self.date), 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
        
        self.account['USDT']['realised_profit'] -= price*amount*self.commission # Minus handling fee
        self.account['USDT']['fee'] += price*amount*self.commission
        self.account[symbol]['fee'] += price*amount*self.commission
        
        if cover_amount > 0: # close 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 # Free 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
        
        return True
    
    def Buy(self, symbol, price, amount, msg=''):
        self.Trade(symbol, 1, price, amount, msg)
        
    def Sell(self, symbol, price, amount, msg=''):
        self.Trade(symbol, -1, price, amount, msg)
        
    def Update(self, date, close_price): # Update assets
        self.date = date
        self.close = close_price
        self.account['USDT']['unrealised_profit'] = 0
        for symbol in self.trade_symbols:
            if np.isnan(close_price[symbol]):
                continue
            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.account['USDT']['total'],4)*self.leverage
        self.df.loc[self.date] = [self.account['USDT']['margin'],self.account['USDT']['total'],self.account['USDT']['leverage'],self.account['USDT']['realised_profit'],self.account['USDT']['unrealised_profit']]

पिछले सप्ताह की समीक्षा

रणनीति कोड 10 अप्रैल को वीचैट समूह में जारी किया गया था। शुरुआत में, लोगों के एक समूह ने रणनीति 2 ((लघु ओवर-राइज और लंबी ओवर-फॉल) चलाया। पहले तीन दिनों में, रिटर्न बहुत अच्छा था, और रिट्रेसमेंट बहुत कम था। अगले दिनों में, कुछ व्यापारी लाभ को बढ़ा दिया, कुछ ने अपने फंड की पूरी राशि का उपयोग भी किया, और लाभ एक दिन में 10% तक पहुंच गया। रणनीति स्क्वायर ने बहुत सारी वास्तविक बाजार रणनीतियों को भी जारी किया, कई लोगों ने रूढ़िवादी अनुशंसित मापदंडों से असंतुष्ट होना शुरू कर दिया, और लेनदेन की मात्रा को बढ़ा दिया। 13 अप्रैल के बाद, BNB के स्वतंत्र प्रवृत्ति के कारण, लाभ पीछे हटना शुरू हो गया और साइडवे। यदि आप 3% trade_value को देखते हैं, तो यह संभवतः 1% पीछे हटना शुरू हो गया। हालांकि, विस्तारित मानों के कारण, कई व्यापारी कम कमाते हैं और हर कोई बहुत कम कमाता है। रिट्रेसमेंट की यह लहर काफी समय पर थी, थोड़ा शांत हो रही थी।

आइए रणनीति 2 के पूर्ण मुद्रा बैकटेस्ट पर एक नज़र डालें। यहाँ, चूंकि यह एक मिनट स्तर का अपडेट है, इसलिए अल्फा पैरामीटर को समायोजित करने की आवश्यकता है। वास्तविक बाजार के दृष्टिकोण से, वक्र प्रवृत्ति सुसंगत है, जो इंगित करती है कि हमारे बैकटेस्ट को एक मजबूत संदर्भ के रूप में इस्तेमाल किया जा सकता है। शुद्ध मूल्य 4.13 से शुद्ध मूल्य के शिखर तक पहुंच गया है और पीछे हटने और साइडवेस के चरण में रहा है।

Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 0.5*trade_value:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -0.5*trade_value:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2a = e

(stragey_2a.df['total']/stragey_2d.initial_balance).plot(figsize=(17,6),grid = True);

रणनीति 1, लघु अल्टकोइन रणनीति सकारात्मक रिटर्न प्राप्त करती है

trade_symbols = list(set(symbols)-set(['LINK','BTC','XTZ','BCH', 'ETH'])) # Selling short currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.00075,log=False)
trade_value = 2000
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        if e.account[symbol]['value'] - trade_value  < -120 :
            e.Sell(symbol, price, round((trade_value-e.account[symbol]['value'])/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if e.account[symbol]['value'] - trade_value > 120 :
            e.Buy(symbol, price, round((e.account[symbol]['value']-trade_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        empty_value += e.account[symbol]['value']
    price = row[1]['BTC']
    if e.account['BTC']['value'] - empty_value < -120:
        e.Buy('BTC', price, round((empty_value-e.account['BTC']['value'])/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if e.account['BTC']['value'] - empty_value > 120:
        e.Sell('BTC', price, round((e.account['BTC']['value']-empty_value)/price,6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_1 = e

(stragey_1.df['total']/stragey_1.initial_balance).plot(figsize=(17,6),grid = True);

रणनीति 2 लंबी ओवर-डॉल खरीदना और छोटी ओवर-प्रोसाइज बिक्री करना लाभ विश्लेषण

अंतिम खाता जानकारी को प्रिंट करने से पता चलता है कि अधिकांश मुद्राओं ने लाभ लाया है, और BNB ने सबसे अधिक नुकसान उठाया है। यह मुख्य रूप से इसलिए भी है क्योंकि BNB स्वतंत्र प्रवृत्ति की लहर से बाहर निकल गया है, बहुत बढ़ रहा है और सबसे बड़ा विचलन 0.06 है।

pd.DataFrame(stragey_2a.account).T.apply(lambda x:round(x,3)).sort_values(by='realised_profit')

# BNB deviation
(price_usdt_btc_norm2.iloc[-7500:].BNB-price_usdt_btc_norm_mean[-7500:]).plot(figsize=(17,6),grid = True);
#price_usdt_btc_norm_mean[-7500:].plot(figsize=(17,6),grid = True);

यदि बीएनबी और एटीओएम को हटा दिया जाए, तो परिणाम बेहतर होगा, लेकिन हाल ही में रणनीति अभी भी पीछे हटने के चरण में होगी।

Alpha = 0.001
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols)-set(['BNB','ATOM']))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 0.5*trade_value:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -0.5*trade_value:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2b = e

(stragey_2b.df['total']/stragey_2b.initial_balance).plot(figsize=(17,6),grid = True);

पिछले दो दिनों में, मुख्यधारा की मुद्रा रणनीतियों को चलाने के लिए लोकप्रिय हो गया है। आइए इस रणनीति का बैकटेस्ट करें। मुद्रा विविधता में कमी के कारण, तुलना के लिए trade_value को 4 गुना बढ़ाया गया था, और परिणामों ने अच्छा प्रदर्शन किया, खासकर क्योंकि हालिया प्रतिगमन छोटा था।

यह ध्यान दिया जाना चाहिए कि केवल मुख्यधारा की मुद्रा अधिक समय के बैकटेस्ट में पूर्ण मुद्रा के रूप में अच्छी नहीं है, और अधिक रिट्रेसमेंट हैं। आप नीचे घंटे की रेखा पर अपना स्वयं का बैकटेस्ट कर सकते हैं, मुख्य रूप से क्योंकि मुद्रा कम बिखरी हुई है और इसके बजाय अस्थिरता बढ़ जाती है।

Alpha = 0.001
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = ['ETH','LTC','EOS','XRP','BCH']
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 1200
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 0.5*trade_value:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -0.5*trade_value:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2c = e

(stragey_2c.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);

प्रसंस्करण शुल्क और रणनीति पैरामीटर विश्लेषण

चूंकि पहले कुछ रिपोर्ट्स ने घंटे के स्तर की लाइन का इस्तेमाल किया, और वास्तविक पैरामीटर वास्तविक बाजार स्थितियों से बहुत अलग हैं, अब मिनट के स्तर की लाइन के साथ, आप कुछ पैरामीटर सेट करने का तरीका देख सकते हैं। पहले डिफ़ॉल्ट पैरामीटर सेटिंग्स देखेंः

• अल्फा = 0.03 घातीय चलती औसत का अल्फा पैरामीटर। सेटिंग जितनी बड़ी होगी, बेंचमार्क मूल्य ट्रैकिंग उतनी ही संवेदनशील होगी और लेनदेन उतने ही कम होंगे। अंतिम होल्डिंग स्थिति भी कम होगी, जिससे लीवरेज कम होगा, लेकिन रिटर्न और अधिकतम रिट्रेसमेंट भी कम होंगे।

• Update_base_price_time_interval = 30 * 60 अल्फा पैरामीटर से संबंधित सेकंड में आधार मूल्य को कितनी बार अपडेट करना है, अल्फा सेटिंग जितनी छोटी होगी, अंतराल उतना ही छोटा सेट किया जा सकता है

• ट्रेड_वैल्यूः अल्टकोइन की कीमत (बीटीसी में तब्दील) का प्रत्येक 1% इंडेक्स होल्डिंग वैल्यू से विचलित होता है, जिसे कुल निवेशित धन और जोखिम वरीयता के अनुसार निर्धारित करने की आवश्यकता होती है। कुल धन का 3-10% सेट करने की सिफारिश की जाती है। आप अनुसंधान वातावरण के बैकटेस्ट के माध्यम से लीवर के आकार को देख सकते हैं। ट्रेड_वैल्यू एडजस्ट_वैल्यू से कम हो सकता है, जैसे कि एडजस्ट_वैल्यू का आधा, जो इंडेक्स से 2% के होल्डिंग वैल्यू के बराबर है।

• Adjust_value: अनुबंध मूल्य (USDT मूल्यांकन) विचलन मूल्य को समायोजित करता है। जब सूचकांक * Trade_value-current position> Adjust_value से विचलित होता है, अर्थात लक्ष्य स्थिति और वर्तमान स्थिति के बीच का अंतर इस मूल्य से अधिक हो जाता है, तो व्यापार शुरू हो जाएगा। बहुत बड़े समायोजन धीमे होते हैं, बहुत छोटे लेनदेन अक्सर होते हैं और 10 से कम नहीं हो सकते हैं, अन्यथा न्यूनतम लेनदेन तक नहीं पहुंच पाएगा, इसे Trade_value के 40% से अधिक पर सेट करने की सिफारिश की जाती है।

यह कहने की जरूरत नहीं है कि Trade_value सीधे हमारी कमाई और जोखिम से संबंधित है। यदि Trade_value नहीं बदला है, तो यह अब तक लाभदायक होना चाहिए।

चूंकि अल्फा के पास इस बार उच्च आवृत्ति डेटा है, इसलिए इसे हर 1 मिनट में अपडेट करना स्पष्ट रूप से अधिक उचित है। स्वाभाविक रूप से, यह मूल एक से छोटा है। विशिष्ट संख्या बैकटेस्ट द्वारा निर्धारित की जा सकती है।

Adjust_value ने हमेशा Trade_value के 40% से अधिक की सिफारिश की है। मूल 1h K लाइन सेटिंग का बहुत कम प्रभाव है। कुछ लोग इसे बहुत कम समायोजित करना चाहते हैं, ताकि यह लक्ष्य स्थिति के करीब हो सके। यहां हम विश्लेषण करेंगे कि इसे क्यों नहीं किया जाना चाहिए।

सबसे पहले शुल्क के प्रबंधन की समस्या का विश्लेषण करें

यह देखा जा सकता है कि 0.00075 की डिफ़ॉल्ट दर के तहत, हैंडलिंग शुल्क 293 है और लाभ 270 है, जो एक बहुत ही उच्च अनुपात है। हम क्या होता है देखने के लिए हैंडलिंग शुल्क को 0 और Adjust_value को 10 पर सेट करते हैं।

stragey_2a.account['USDT']

{'fee': 293.85972778530453,
 'leverage': 0.45999999999999996,
 'margin': 236.23559736312995,
 'realised_profit': 281.77464608744435,
 'total': 10271.146238,
 'unrealised_profit': -10.628408369648495}

Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 10:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < 10:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2d = e

(stragey_2d.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);

परिणाम एक सीधी रेखा ऊपर की ओर है, बीएनबी केवल थोड़ा मोड़ और मोड़ लाता है, निचला एडजस्ट_वैल्यू हर उतार-चढ़ाव को पकड़ता है। यदि कोई हैंडलिंग शुल्क नहीं है, तो लाभ उत्कृष्ट होगा।

क्या होगा अगर समायोजन_मूल्य छोटा है अगर एक छोटी राशि हैंडलिंग शुल्क है?

Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[-7500:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 10:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < 10:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2e = e
(stragey_2e.df['total']/e.initial_balance).plot(figsize=(17,6),grid = True);

नतीजतन, यह भी एक सीधी रेखा नीचे की ओर वक्र से बाहर आया। यह समझना आसान है कि यदि आप इसके बारे में सोचते हैं, तो एक छोटे से स्प्रेड के भीतर लगातार समायोजन केवल हैंडलिंग शुल्क खो देंगे।

कुल मिलाकर, शुल्क का स्तर जितना कम होगा, Adjust_value जितना छोटा सेट किया जा सकेगा, लेनदेन उतना ही अधिक होगा और लाभ उतना ही अधिक होगा।

अल्फा सेटिंग्स के साथ समस्याएं

चूंकि एक मिनट लाइन है, इसलिए बेंचमार्क मूल्य प्रति मिनट एक बार अपडेट किया जाएगा, यहाँ हम बस अल्फा के आकार को निर्धारित करने के लिए बैकटेस्ट करते हैं। वर्तमान अनुशंसित अल्फा सेटिंग 0.001 है।

for Alpha in [0.0001, 0.0003, 0.0006, 0.001, 0.0015, 0.002, 0.004, 0.01, 0.02]:
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
    price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() #Here is consistent with the strategy, using EMA
    trade_symbols = list(set(symbols))
    price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
    e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
    trade_value = 300
    for row in price_usdt.iloc[-7500:].iterrows():
        e.Update(row[0], row[1])
        for symbol in trade_symbols:
            price = row[1][symbol]
            if np.isnan(price):
                continue
            diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
            aim_value = -trade_value*round(diff/0.01,1)
            now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
            if aim_value - now_value > 0.5*trade_value:
                e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
            if aim_value - now_value < -0.5*trade_value:
                e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    print(Alpha, e.account['USDT']['unrealised_profit']+e.account['USDT']['realised_profit'])

0.0001 -77.80281760941007
0.0003 179.38803796199724
0.0006 218.12579924541367
0.001 271.1462377177959
0.0015 250.0014065973528
0.002 207.38692166891275
0.004 129.08021828803027
0.01 65.12410041648158
0.02 58.62356792410955

पिछले दो महीनों में मिनट लाइन के बैकटेस्ट परिणाम

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

एक और बात, हम हमेशा एक निश्चित व्यापार मूल्य का उपयोग कर रहे हैं, जो बाद की अवधि में धन का उपयोग अपर्याप्त बनाता है, और वास्तविक वापसी दर अभी भी बहुत बढ़ सकती है।

हम दो महीने की बैकटेस्ट अवधि में कहां हैं?

Alpha = 0.001
#price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.rolling(20).mean() # Ordinary moving average
price_usdt_btc_norm2 = price_usdt_btc/price_usdt_btc.ewm(alpha=Alpha).mean() # Here is consistent with the strategy, using EMA
trade_symbols = list(set(symbols))
price_usdt_btc_norm_mean = price_usdt_btc_norm2[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.00075,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm2.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,1)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        if aim_value - now_value > 0.5*trade_value:
            e.Buy(symbol, price, round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
        if aim_value - now_value < -0.5*trade_value:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
stragey_2f = e

(stragey_2f.df['total']/stragey_2e.initial_balance).plot(figsize=(17,6),grid = True);

(stragey_2f.df['leverage']/stragey_2e.initial_balance).plot(figsize=(17,6),grid = True);