संसाधन लोड हो रहा है... लोड करना...

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

लेखक:अच्छाई, बनाया गयाः 2020-05-09 11:14:50, अद्यतन किया गयाः 2023-11-04 19:49:01

डैशबोर्ड पृष्ठ पर खोज बटन पर क्लिक करें, और फिर प्रवेश करने के लिए तीर पर क्लिक करें. अपलोड की गई.pynb प्रत्यय फ़ाइल खोलें और लाइन द्वारा लाइन चलाने के लिए shift + enter दबाएं. अनुसंधान वातावरण के उपयोग सहायता में बुनियादी ट्यूटोरियल हैं.

रणनीतिक कारण

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

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

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

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

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

आवश्यक मुद्रा को स्क्रीन करें

बिनेंस परपेचुअल कॉन्ट्रैक्ट वर्तमान में सूचीबद्ध करेंसी, जो इसके एपीआई इंटरफेस का उपयोग करके प्राप्त की जा सकती है, की कुल संख्या 23 है (बीटीसी को छोड़कर) ।

#Info = requests.get('https://fapi.binance.com/fapi/v1/exchangeInfo')
#symbols = [symbol_info['baseAsset'] for symbol_info in Info.json()['symbols']]
symbols = ['ETH', 'BCH', 'XRP', 'EOS', 'LTC', 'TRX', 'ETC', 'LINK', 'XLM', 'ADA', 'XMR', 'DASH', 'ZEC', 'XTZ', 'BNB', 'ATOM', 'ONT', 'IOTA', 'BAT', 'VET', 'NEO', 'QTUM', 'IOST']

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

price_btc = pd.read_csv('https://www.fmz.com/upload/asset/1ef1af8ec28a75a2dcb.csv', index_col = 0)
price_btc.index = pd.to_datetime(price_btc.index,unit='ms') #Index date

price_btc.tail()

परिणाम:

5 पंक्तियाँ × 23 स्तंभ

सबसे पहले इन मुद्राओं की कीमतों को खींचें ताकि प्रवृत्ति को देखा जा सके, डेटा को सामान्य किया जाना चाहिए। यह देखा जा सकता है कि चार मुद्राओं को छोड़कर, अन्य मुद्राओं के मूल्य प्रवृत्तियां मूल रूप से समान हैं, जो एक गिरावट की प्रवृत्ति दिखाती हैं।

price_btc_norm = price_btc/price_btc.fillna(method='bfill').iloc[0,]
price_btc_norm.plot(figsize=(16,6),grid = True,legend=False);

अंतिम मूल्य परिवर्तनों को सॉर्ट करके, आप कई सिक्के पा सकते हैं जो स्पष्ट रूप से अलग हैं, अर्थात् LINK, XTZ, BCH, ETH। समझाएं कि वे अक्सर अपनी प्रवृत्ति चला सकते हैं, और उन्हें छोटा करना एक उच्च जोखिम है और रणनीति से बाहर रखा जाना चाहिए।

शेष मुद्राओं के सहसंबंध गुणांक का हीट मैप बनाएं, और पाएँ कि ईटीसी और एटीओएम का रुझान भी अपेक्षाकृत विशेष है और इसे बाहर रखा जा सकता है।

price_btc_norm.iloc[-1,].sort_values()[-5:]

परिणाम:

ETH     0.600417
ETC     0.661616
BCH     1.141961
XTZ     2.512195
LINK    2.764495
Name: 2020-03-25 00:00:00, dtype: float64

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies

plt.subplots(figsize=(12, 12)) # Set the screen size
sns.heatmap(price_btc[trade_symbols].corr(), annot=True, vmax=1, square=True, cmap="Blues");

पिछले शेष मुद्रा में प्रति वर्ष औसतन 66% की गिरावट आई, जाहिर है कि शॉर्टिंग के लिए पर्याप्त जगह है। अल्टकोइन मूल्य सूचकांक में इन सिक्कों की प्रवृत्ति को संश्लेषित करते हुए, यह पाया गया कि यह मूल रूप से सभी तरह से गिर गया, यह पिछले साल की दूसरी छमाही में अधिक स्थिर था, और इस साल सभी तरह से गिरना शुरू हुआ। इस अध्ययन में LINK, XTZ, BCH, ETH, ETC, ATOM, BNB, EOS, LTC ने पहली रणनीति के शॉर्ट में भाग नहीं लिया, विशिष्ट विवरण स्वयं द्वारा बैकटेस्ट किए जा सकते हैं।

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

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # You can set the remaining currencies, which you want to subtract.
1-price_btc_norm[trade_symbols].iloc[-1,].mean()

परिणाम:

0.6714306758250285

price_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

बाइनेंस स्थिरता डेटा

इसी तरह, बिनेंस सस्टेनेबिलिटी के डेटा को संकलित किया गया है, आप इसे सीधे अपनी नोटबुक में भी उद्धृत कर सकते हैं, डेटा 28 जनवरी से 31 मार्च, 2020 तक 1h बाजार K लाइन है, क्योंकि अधिकांश बिनेंस स्थायी अनुबंध केवल दो महीने के लिए दोपहर का भोजन किया गया है, इसलिए डेटा बैकटेस्ट के लिए पर्याप्त है।

price_usdt = pd.read_csv('https://www.fmz.com/upload/asset/20227de6c1d10cb9dd1.csv ', index_col = 0)
price_usdt.index = pd.to_datetime(price_usdt.index)

price_usdt.tail()

परिणाम:

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

price_usdt_norm = price_usdt/price_usdt.fillna(method='bfill').iloc[0,]
price_usdt_norm.plot(figsize=(16,6),grid = True,legend=False);

हम बिटकॉइन के मुकाबले बेचना चाहते सिक्के के सूचकांक मूल्य को आकर्षित करें, रणनीति सिद्धांत इस वक्र को छोटा करना है, और रिटर्न मूल रूप से इस वक्र के विपरीत है।

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,]
price_usdt_btc_norm[trade_symbols].mean(axis=1).plot(figsize=(16,6),grid = True);
#price_usdt_btc_norm.mean(axis=1).plot(figsize=(16,6),grid = True,legend=False);

बैकटेस्ट इंजन

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

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

एक्सचेंज ऑब्जेक्ट बनाते समय, आपको उस मुद्रा को निर्दिष्ट करने की आवश्यकता होती है जिसका व्यापार किया जाना है। खरीदना लंबा है और बेचना छोटा है। स्थायी अनुबंध सीमा के कारण, जब स्थिति खोलने पर, लंबी और छोटी स्थिति स्वचालित रूप से एक साथ बंद हो जाती है। जब बिक्री छोटी स्थिति और मुद्राओं की संख्या नकारात्मक होती है। पैरामीटर निम्नानुसार हैंः

trade_symbols: व्यापार करने वाली मुद्राओं की सूची
लीवरेजः लीवरेज, प्रभाव मार्जिन,
कमीशनः लेनदेन शुल्क, डिफ़ॉल्ट 0.00005
initial_balance: आरंभिक परिसंपत्ति, USDT मूल्यांकन
लॉगः लेनदेन रिकॉर्ड मुद्रित करना है या नहीं

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}}
        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}
            
    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 transaction fee
        
        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 the 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']
            if self.date.hour in [0,8,16]:
                pass
                self.account['USDT']['realised_profit'] += -self.account[symbol]['amount']*close_price[symbol]*0.01/100
        
        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']]

# First test the backtest engine
e = Exchange(['BTC','XRP'],initial_balance=10000,commission=0,log=True)

e.Buy('BTC',100, 5)
e.Sell('XRP',10, 50)

e.Sell('BTC',105,e.account['BTC']['amount'])
e.Buy('XRP',9,-e.account['XRP']['amount'])

round(e.account['USDT']['realised_profit'],4)

75.0

पहला रणनीति कोड

रणनीतिक तर्क:

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

लघु व्यापार_मूल्य स्थिति स्थिति का आकार निर्धारित करता है. सेटिंग लॉग = सच लेनदेन लॉग प्रिंट करेगा

# Need to hedge with BTC
trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].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  < -20 :
            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 > 20 :
            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 < -20:
        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 > 20:
        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

प्रत्येक मुद्रा का अंतिम लाभ इस प्रकार है:

pd.DataFrame(stragey_1.account).T.apply(lambda x:round(x,3))

नीचे दिए गए दो ग्राफ शुद्ध संपत्ति वक्र और उपयोग किए गए लाभ का संकेत देते हैं।

नेट वर्थ वक्र में पीला रंग 1x लीवरेज का प्रभाव है जो अल्टकोइन सूचकांक को छोटा करता है। यह देखा जा सकता है कि रणनीति मूल रूप से सूचकांक के उतार-चढ़ाव को बढ़ाता है, जो उम्मीदों के अनुरूप है। अंतिम दो महीने का रिटर्न 60% है, अधिकतम रिट्रेसमेंट 20% है, और अधिकतम लीवरेज लगभग 8 गुना है। अधिकांश समय, यह 6 गुना से कम है। यह अभी भी सुरक्षित है। सबसे महत्वपूर्ण बात, पूर्ण हेजिंग ने रणनीति को 12 मार्च की गिरावट में बहुत कम खो दिया है।

जब शॉर्ट-सेलिंग मुद्रा की कीमत बढ़ जाती है और अनुबंध मूल्य बढ़ता है, तो स्थिति कम हो जाती है, दूसरी ओर, लाभ प्राप्त करते समय, स्थिति बढ़ जाती है। इससे अनुबंध का कुल मूल्य स्थिर रहता है, भले ही आसमान छूने वाली गिरावट में सीमित नुकसान हो।

लेकिन जोखिम भी पहले उल्लेख किया गया था, altcoins अपने स्वयं के प्रवृत्ति चलाने के लिए बहुत संभावना है, और नीचे से बहुत बढ़ सकता है. यह कैसे इसका उपयोग करने के लिए पर निर्भर करता है. यदि आप altcoin के बारे में आशावादी हैं और लगता है कि यह नीचे तक पहुँच गया है, आप दिशा में संचालित कर सकते हैं और लंबे समय तक इस सूचकांक खरीद. या यदि आप कुछ मुद्राओं के बारे में आशावादी हैं, तो आप उनके साथ हेज कर सकते हैं.

(stragey_1.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
#(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

# Strategy leverage
stragey_1.df['leverage'].plot(figsize=(18,6),grid = True);

इसके अलावा, चूंकि USDT के मुकाबले altcoin की कीमत भी गिर गई, इसलिए चरम योजना को सीधे शॉर्ट बेचकर हेज नहीं किया गया है, लेकिन उतार-चढ़ाव बहुत बड़ा है और रिट्रेसमेंट उच्च है।

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH', 'ETC','ATOM','BNB','EOS','LTC'])) # Remaining currencies
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 2000
for row in price_usdt.iloc[:].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  < -20 :
            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 > 20 :
            pass
            #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']
stragey_1b = e

(stragey_1b.df['total']/stragey_1.initial_balance).plot(figsize=(18,6),grid = True); # Net worth curve
(2-price_usdt_btc_norm[trade_symbols].mean(axis=1)).plot(figsize=(18,6),grid = True);

दूसरी रणनीति कोड

रणनीतिक तर्क:

जांचें कि क्या कोई कीमत है या व्यापार करने के लिए कोई कीमत है
मुद्रा मूल्य के सूचकांक से विचलन की जाँच करें
विचलन निर्णय के आधार पर लंबे और छोटे जाओ, और विचलन आकार के अनुसार स्थिति का न्याय
बीटीसी के साथ असुरक्षित पदों की गणना और हेजिंग

Trade_value भी खुले पदों के आकार को नियंत्रित करता है. आप भी diff/0.001 के रूपांतरण कारक को संशोधित कर सकते हैं

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.loc[row[0],symbol] - price_usdt_btc_norm_mean[row[0]]
        aim_value = -trade_value*round(diff/0.01,0)
        now_value = e.account[symbol]['value']*np.sign(e.account[symbol]['amount'])
        empty_value += now_value
        if aim_value - now_value > 50:
            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 < -50:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 50:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -50:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2 = e

दूसरी रणनीति का रिटर्न पहली रणनीति से बहुत बेहतर है। पिछले दो महीनों में, इसमें 100% रिटर्न है, लेकिन अभी भी 20% रिट्रेसमेंट है। पिछले सप्ताह, छोटे बाजार उतार-चढ़ाव के कारण, रिटर्न स्पष्ट नहीं है। समग्र लाभप्रदता बहुत अधिक नहीं है। यह रणनीति कोशिश करने लायक है। विचलन की डिग्री के आधार पर, 7800 USDT से अधिक की स्थिति खोली गई थी।

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

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

# Summary results by currency
pd.DataFrame(e.account).T.apply(lambda x:round(x,3))

e.df['leverage'].plot(figsize=(18,6),grid = True);

यदि हेजिंग न करने का परिणाम निम्नानुसार है, तो अंतर वास्तव में बहुत अधिक नहीं है। क्योंकि लंबी और छोटी स्थिति मूल रूप से संतुलित होती है।

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) # Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.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'])
        empty_value += now_value
        if aim_value - now_value > 20:
            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 < -20:
            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_2.initial_balance).plot(figsize=(18,6),grid = True);
#(stragey_2.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True); # Can be stacked together

यदि आप USDT मूल्य प्रतिगमन का उल्लेख करते हैं, तो प्रभाव बहुत बुरा होगा

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH']))+['BTC'] #Remaining currencies
price_usdt_norm_mean = price_usdt_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols,initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols+['BTC']:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_norm.loc[row[0],symbol] - price_usdt_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'])
        empty_value += now_value
        if aim_value - now_value > 20:
            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 < -20:
            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']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);
(stragey_2b.df['total']/stragey_2.initial_balance).plot(figsize=(18,6),grid = True);

यदि आप अधिकतम स्थिति मूल्य को सीमित करते हैं, प्रदर्शन बदतर हो जाएगा

trade_symbols = list(set(symbols)-set(['LINK','XTZ','BCH', 'ETH'])) #Remaining currencies
price_usdt_btc_norm_mean = price_usdt_btc_norm[trade_symbols].mean(axis=1)
e = Exchange(trade_symbols+['BTC'],initial_balance=10000,commission=0.0005,log=False)
trade_value = 300
for row in price_usdt.iloc[:].iterrows():
    e.Update(row[0], row[1])
    empty_value = 0
    for symbol in trade_symbols:
        price = row[1][symbol]
        if np.isnan(price):
            continue
        diff = price_usdt_btc_norm.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'])
        empty_value += now_value
        if aim_value - now_value > 20 and abs(aim_value)<3000:
            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 < -20 and abs(aim_value)<3000:
            e.Sell(symbol, price, -round((aim_value - now_value)/price, 6),round(e.account[symbol]['realised_profit']+e.account[symbol]['unrealised_profit'],2))
    price = row[1]['BTC']
    aim_value = -empty_value
    now_value = e.account['BTC']['value']*np.sign(e.account['BTC']['amount'])
    if aim_value - now_value > 20:
        e.Buy('BTC', price, round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
    if aim_value - now_value < -20:
        e.Sell('BTC', price, -round((aim_value - now_value)/price, 6),round(e.account['BTC']['realised_profit']+e.account['BTC']['unrealised_profit'],2))
stragey_2d = e

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

सारांश और जोखिम

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

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

रणनीति के प्रारंभ के समय और विशिष्ट मापदंडों के भिन्न होने के कारण, इस रणनीति का लंबे समय तक उपयोग करने वाले लोगों का प्रभाव बहुत बड़ा नहीं होना चाहिए।

संक्षेप में, कोई सही रणनीति नहीं है, केवल रणनीति के प्रति सही दृष्टिकोण है, यह अंततः जोखिमों की समझ और भविष्य के बारे में उपयोगकर्ता के निर्णय पर निर्भर करता है।

संबंधित

अधिक

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