उन्नत प्लेटफार्म अनुसंधान पायथन डेटा विश्लेषण और रणनीति बैकटेस्ट

लेखक:निनाबादास, बनाया गयाः 2022-04-13 09:12:47, अद्यतन किया गयाः 2022-04-28 11:06:13

उन्नत प्लेटफार्म अनुसंधान पायथन डेटा विश्लेषण और रणनीति बैकटेस्ट.ipynb

उन्नत प्लेटफार्म अनुसंधान

FMZ में एक अंतर्निहित jupyter नोटबुक है जो उपयोगकर्ताओं को प्लेटफ़ॉर्म एपीआई से परिचित होने और रणनीति अनुसंधान करने में मदद करता है, और पायथन 3 C ++ 11/17 और जावास्क्रिप्ट के सीखने के वातावरण का समर्थन करता है। नोटबुक+पायथन एक बहुत शक्तिशाली उपकरण है, जो डेटा विश्लेषण और रणनीति अनुसंधान के लिए लगभग अपरिहार्य है। हालांकि FMZ प्लेटफ़ॉर्म के साथ आने वाला बैकटेस्ट बहुत उपयोगी है, यह जटिल और बड़ी डेटा मात्रा वाली रणनीतियों के लिए उपयुक्त नहीं है। यह लेख jupyter नोटबुक के कुछ उन्नत उपयोग कौशल पेश करेगा, और यादृच्छिक जोड़ी व्यापार और बहु-जोड़ी व्यापार रणनीतियों के बैकटेस्ट का एहसास करेगा।

जुपिटर का प्रयोग

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

ट्यूटोरियल

नोटबुक और पायथन के विशिष्ट उपयोग कौशल के लिए कई ऑनलाइन ट्यूटोरियल हैं। आप पायथन क्वांटिफिकेशन और जूपिटर नोटबुक ट्यूटोरियल जैसे कीवर्ड खोजकर बहुत सारी जानकारी पा सकते हैं। आपको क्रॉलर, डेटा प्रोसेसिंग, बैकटेस्ट, रणनीति डिजाइन और प्लॉटिंग जैसी मूल बातें सीखने और मास्टर करने की आवश्यकता है।

डेटा अधिग्रहण

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

इसके बाद, हम दिखाएंगे कि बिनेंस पर स्थायी अनुबंधों के के-लाइन डेटा को कैसे प्राप्त और संग्रहीत किया जाए।

सबसे पहले, Binance Perpetual Swap दस्तावेज खोजेंःhttps://binance-docs.github.io/apidocs/futures/cn/#c59e471e81. आप आवश्यक मापदंडों और लौटाए गए डेटा प्रारूपों को देख सकते हैं। आमतौर पर, एपीआई द्वारा अधिग्रहित के-लाइनों की संख्या सीमित होती है, और बाइनेंस में अधिकतम 1000 होते हैं, इसलिए इसे लूप पुनरावृत्ति द्वारा अधिग्रहित करने की आवश्यकता होती है। अन्य प्लेटफार्मों पर स्थिति बाइनेंस के समान है। ध्यान दें कि नेटवर्क को विदेशी नेटवर्क से कनेक्ट करने की आवश्यकता है (चीन में घरेलू नेटवर्क की तुलना में) के-लाइनों को क्रॉल करने के लिए।

अवधि Binance समर्थन करता हैः 1m, 3m, 5m, 15m, 30m, 1h, 2h, 4h, 6h, 8h, 12h, 1d, 3d, 1w, 1M।

[24] मेंः आम पुस्तकालय के लिए आयात अनुरोध #नेटवर्क अनुरोध आयात की तारीख से समय आयात का समय पीडी के रूप में आयात पांडा [160 में]: def GetKlines ((प्रतीक=BTC,start=2020-8-10,end=2021-8-10,period=1h): क्लाईन्स = [] start_time = int(time.mktime(datetime.strptime(start, %Y-%m-%d).timetuple))) *1000 end_time = int(time.mktime(datetime.strptime(end, %Y-%m-%d).timetuple))) *1000 जबकि start_time < end_time: res = requests.get(https://fapi.binance.com/fapi/v1/klines?symbol=%sUSDT&interval=%s&startTime=%s&limit=1000%(symbol,period,start_time)) res_list = res.json() क्लाईन्स += res_list #print ((datetime.utcfromtimestamp ((start_time/1000).strftime(%Y-%m-%d %H:%M:%S),len ((res_list)) start_time = res_list[-1][0] return pd.DataFrame(Klines,columns=[time,open,high,low,close,amount,end_time,volume,count,buy_amount,buy_volume,null]).astype(float) [85] मेंः df = GetKlines ((प्रतीक=BTC,start=2021-1-1,end=2021-8-10,period=1h)

डेटा भंडारण और पढ़ने के लिए पांडा पुस्तकालय के अंदर के कार्यों का उपयोग कर सकते हैं। प्रारूप csv है, जिसे सीधे एक्सेल सॉफ्टवेयर के साथ खोला जा सकता है।

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

[86] मेंः df.to_csv ((btc_klines.csv) df = pd.read_csv ((btc_klines.csv,index_col=0) [87] मेंः डीएफ बाहर[87]: ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,, खोलने का समय उच्च निम्न बंद राशि अंत_समय मात्रा गणना buy_amount buy_volume शून्य 0 1596988800000 11575.08 11642.00 11566.07 11591.37 6541.466 1596992399999 7.592336e+07 25724 3127.898 3.630633e+07 0 1 1596992400000 11591.39 11610.23 11526.90 11534.39 6969.252 1596995999999 8.057780e+07 27403 3390.424 3.920162e+07 0 2 1596996000000 11534.39 11656.69 11527.93 11641.07 6439.365 1596999599999 7.469135e+07 25403 3446.186 3.997906e+07 0 3 1596999600000 11641.06 11665.90 11624.20 11635.30 3911.582 1597003199999 4.555459e+07 17820 1842.413 2.145768e+07 0 4 1597003200000 11635.29 11684.00 11635.29 11673.81 3461.004 1597006799999 4.036804e+07 15513 1660.575 1.936981e+07 0 ....................................................................................... 8805 1628658000000 45627.72 45894.53 45540.00 45801.45 10296.202 1628661599999 4.710187e+08 112187 4988.565 2.282399e+08 0 8806 1628661600000 45801.46 46270.00 45800.01 46087.86 26409.962 1628665199999 1.215164e+09 247170 13696.301 6.302708e+08 0 8807 1628665200000 46087.87 46450.00 46087.87 46367.38 23969.309 1628668799999 1.110210e+09 232348 11990.951 5.554267e+08 0 8808 1628668800000 46367.37 46643.13 46002.01 46217.01 23472.769 1628672399999 1.086549e+09 229533 12334.292 5.711837e+08 0 8809 1628672400000 46217.01 46329.69 46046.54 46297.16 6579.477 16286759999 3.039580e+08 78812 3313.055 1.530718e+08 0 , 8810 पंक्तियाँ × 12 स्तंभ

, [88] मेंः df.index = pd.to_datetime ((df.time,unit=ms) #सूचकांक को दिनांक में परिवर्तित करें, जो ग्राफिंग के लिए सुविधाजनक है [89] मेंः df.close.plot ((figsize=(15,6),grid = True); #close price बाहर[1]:img[92] मेंः (df.buy_amount.rolling(150).mean()/df.amount.rolling(150.mean()).plot ((figsize=(15,6),grid = True); #फ्लैट के बाद, पहल खरीद राशि का अनुपात #इस स्थिति में कि नींव पर पहुंचने के बाद पहल खरीद राशि का अनुपात बढ़ जाता है, आम तौर पर मूल्य वृद्धि की स्थिति का जवाब देता है, लेकिन पहल खरीद राशि के अनुपात का दीर्घकालिक औसत 49% है बाहर[1]:img[93] मेंः (df[count].rolling(100).mean (()).plot ((figsize=(15,6),grid = True); #फ्लैट के बाद निष्पादित राशि,और बाजार उद्धरण कम स्थान पर तैयार किए जा सकते हैं बाहर[1]:img

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

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

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

विनिमय वर्ग का परिचयः

  • account:USDT आधार मुद्रा दर्शाता है, जो आवश्यक नहीं है; realised_profit: लाभ और हानि पहले ही प्राप्त; unrealised_profit: लाभ और हानि अभी तक प्राप्त नहीं; कुलः कुल इक्विटी; शुल्कः हैंडलिंग शुल्क। अन्य ट्रेडिंग जोड़े के लिए, राशि (जो शॉर्टिंग के समय नकारात्मक संख्या है); hold_price: होल्डिंग मूल्य; मूल्यः होल्डिंग मूल्य; मूल्यः वर्तमान मूल्य।

  • trade_symbols: ट्रेडिंग जोड़े की सरणी; आप एक ट्रेडिंग जोड़ी में भी पास कर सकते हैं; डिफ़ॉल्ट उद्धरण मुद्रा USDT है, लेकिन आप बैकटेस्ट के लिए अन्य उद्धरण मुद्रा प्रतीकों का भी उपयोग कर सकते हैं।

  • शुल्कः वितरण शुल्क; सरलता से, निर्माता और प्राप्तकर्ता में अंतर न करें।

  • initial_balance: आरंभिक संपत्ति; डिफ़ॉल्ट ट्रेडिंग जोड़े की आरंभिक राशि 0 है।

  • खरीद कार्यः खरीदना, जो एक मिलान तंत्र के बिना, स्थायी अनुबंधों के लंबे और बंद करने के लिए कम है।

  • बिक्री कार्यः बेचना।

  • अद्यतन कार्यः खाता जानकारी को अद्यतन करने के लिए, जिसे सभी व्यापारिक जोड़े के मूल्य शब्दकोश में पारित करने की आवश्यकता होती है। [98] मेंः वर्ग विनिमयः

    def आरंभ करना(स्वयं, trade_symbols, शुल्क=0.0004, प्रारंभिक_शेष=10000): self.initial_balance = initial_balance #प्रारंभिक शेष राशि स्व. शुल्क = शुल्क self.trade_symbols = trade_symbols self.account = {USDT:{realised_profit:0, unrealised_profit:0, total:initial_balance, fee:0}} trade_symbols में प्रतीक के लिएः self.account[symbol] = {amount:0, hold_price:0, value:0, price:0, realised_profit:0,unrealised_profit:0,fee:0}

    व्यापार (स्वयं, प्रतीक, दिशा, मूल्य, राशि):

      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.fee #take out the fee 
      self.account['USDT']['fee'] += price*amount*self.fee
      self.account[symbol]['fee'] += price*amount*self.fee
    
      if cover_amount > 0: #close first 
          self.account['USDT']['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount  #profit 
          self.account[symbol]['realised_profit'] += -direction*(price - self.account[symbol]['hold_price'])*cover_amount
          
          self.account[symbol]['amount'] -= -direction*cover_amount
          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[symbol]['hold_price'] = total_cost/total_amount
          self.account[symbol]['amount'] += direction*open_amount
    

    def खरीदें (स्वयं, प्रतीक, मूल्य, राशि):self.Trade(प्रतीक, 1, मूल्य, राशि)

    def बेचना (स्वयं, प्रतीक, मूल्य, राशि):self.Trade(प्रतीक, -1, मूल्य, राशि)

    def Update ((self, close_price): #सम्पत्तियों को अपडेट करें स्व.खाते[USDT][असत्य_लाभ] = 0 self.trade_symbols में प्रतीक के लिएः self.account[symbol][unrealised_profit] = (close_price[symbol] - self.account[symbol][hold_price]) *self.account[symbol][amount] self.account[प्रतीक][price] = close_price[प्रतीक] self.account[symbol][value] = abs(self.account[symbol][amount]) *close_price[symbol] स्व.खाता[USDT][असत्य_लाभ] += स्व.खाता[प्रतीक][असत्य_लाभ] स्व.खाते[USDT][कुल] = गोल(स्व.खाते[USDT][वास्तविक_लाभ] + स्व.शुरुआती_वित्त + स्व.खाते[USDT][अवास्तविक_लाभ],6) [117] मेंः #परीक्षण में, आप देख सकते हैं कि इस बात पर कोई जोर नहीं दिया गया है कि प्लेटफ़ॉर्म यूएसडीटी-मार्जिन या स्पॉट है। वास्तव में, परिणाम समान है, जो कि कोई अंतर नहीं है। e = Exchange([BTC], शुल्क=0.0004, initial_balance=10000) #एक Exchange ऑब्जेक्ट बनाएं, और केवल एक BTC की ट्रेडिंग जोड़ी e.BTC ,40000, 0.1) खरीदें# 40,000 की कीमत पर 0.1 BTC खरीदें e. बेचना ((BTC,41000, 0.1) # 41000 की कीमत पर 0.1 BTC बेचना e.Update (({BTC:41000}) #अपडेट खाता जानकारी प्रिंट ((ई.खाता) #अंतिम खाता जानकारी print (('लाभः ',round(e.account[USDT][total]-e.initial_balance,2)) आउट[117]:{USDT: {वास्तविक_लाभ: 96.76, अवास्तविक_लाभ: 0.0, कुल: 10096.76, शुल्क: 3.24}, BTC: {राशि: 0.0, धार_मूल्य: 0, मूल्य: 0.0, मूल्य: 000, 41 वास्तविक_लाभ: 100.0, अवास्तविक_लाभ: 0.0, शुल्क: 3.24}} लाभः 96.76

ग्रिड रणनीति बैकटेस्ट

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

Live के शीर्ष पर, एक आधिकारिक बॉट है, जो 4 अप्रैल, 2021 से शुरू हुआ; स्थिति मूल्य 150 है, ग्रिड अंतराल 0.01 है, और वर्तमान लाभ 3600USDT है। एक ही मापदंडों और 5min K-लाइन का उपयोग करके बैकटेस्ट करने के लिए, लाभ 3937USDT है। चूंकि बॉट की शुरुआत में स्थिति मूल्य 150 USDT से कम है, इसलिए परिणाम काफी सटीक है। यदि आप ग्रिड अंतराल को 0.005 में बदलते हैं, तो लाभ 5226U होगा। 0.005 का ग्रिड अंतराल स्पष्ट रूप से 0.01 की तुलना में एक बेहतर पैरामीटर है, जिसे पता लगाने के लिए बैकटेस्ट करने की आवश्यकता है।

के-लाइन अवधि जितनी कम होगी, उतने ही सटीक बैकटेस्ट परिणाम होंगे, और जितनी बड़ी मात्रा में डेटा की आवश्यकता होगी। पाठक प्रतीक पैरामीटर को उस ट्रेडिंग जोड़ी में बदलने का प्रयास कर सकते हैं जिसे वे बैकटेस्ट करना चाहते हैं।

[241] मेंः प्रतीक = TRX df = GetKlines ((प्रतीक=प्रतीक,start=2021-4-4,end=2021-8-11,period=5m) [286] मेंः मूल्य = 150 pct = 0.01

e = विनिमय (([प्रतीक], शुल्क=0.0002, प्रारंभिक_शेष=10000) init_price = df.loc[0,close] res_list = [] #मध्य परिणाम को संग्रहीत करने के लिए उपयोग किया जाता है df.iterrows में पंक्ति के लिएः kline = पंक्ति[1] #जो केवल एक K-लाइन का परीक्षण करेगा और केवल एक खरीद आदेश या एक बिक्री आदेश प्राप्त करेगा, जो बहुत सटीक नहीं है buy_price = (value / pct - value) / ((value / pct) / init_price + e.account[symbol][amount]) #sell order price, क्योंकि यह एक निर्माता निष्पादन है, यह भी अंतिम मिलान मूल्य है sell_price = (value / pct + value) / ((value / pct) / init_price + e.account[symbol][amount])

if kline.low < buy_price: #the lowest price of K-line is less than the current maker price; the buy order is executed 
    e.Buy(symbol,buy_price,value/buy_price)
if kline.high > sell_price:
    e.Sell(symbol,sell_price,value/sell_price)
e.Update({symbol:kline.close})
res_list.append([kline.time, kline.close, e.account[symbol]['amount'], e.account['USDT']['total']-e.initial_balance])

res = pd.DataFrame ((data=res_list, columns=[time,price,amount,profit]) res.index = pd.to_datetime ((res.time,unit=ms) [287] मेंः ई.खाता आउट[287]:{USDT: {realised_profit: 3866.633149565143, अवास्तविक लाभ: 70.54622281993666, कुल : 13937.179372, शुल्क: 177.51000000000596}, TRX: {राशि: 36497.43208747655, होल्ड_प्राइस: 0.08203709078461048, मूल्य: 3064.689372385406, मूल्य : 0.08397, वास्तविक_लाभ: 4044.143149565462, अवास्तविक लाभ: 70.54622281993666, शुल्क : 177.51000000000596}} [288] मेंः res.profit.plot ((figsize=(15,6),grid = True); बाहर[1]:img[170 में]: res.price.plot ((figsize=(15,6),grid = True); #close price बाहर[170]:img

स्पॉट संतुलन रणनीति बैकटेस्ट

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

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

[290 में]: प्रतीक = [BTC,ETH,LTC,XRP] डेटा = {} प्रतीकों में प्रतीक के लिएः df = GetKlines ((प्रतीक=प्रतीक,start=2020-8-11,end=2021-8-11,period=1h) डेटा[प्रतीक] = df.close [291] मेंः df = pd.DataFrame (([data[symbol].symbols में प्रतीक के लिए मान],index=symbols).T [302] मेंः e = विनिमय ((प्रतीक, शुल्क=0.0004, प्रारंभिक_शेष=10000) res_list = [] df.iterrows में पंक्ति के लिएः कीमतें = पंक्ति[1] कुल = ई.खाता[USDT][कुल] e.अद्यतन (मूल्य) प्रतीकों में प्रतीक के लिएः pct = e.account[symbol][value]/कुल यदि pct > 0.26: ई.बिक्री ((प्रतीक,मूल्य[प्रतीक],(बिंदु-0.25) *कुल/मूल्य[प्रतीक]) यदि pct < 0.24: ई.खरीदें ((प्रतीक,मूल्य[प्रतीक],(0.25 प्रतिशत) *कुल/मूल्य[प्रतीक]) res_list.append (([e.account[symbol][value] प्रतीक में प्रतीक के लिए] + [e.account[USDT][total]]) res = pd.DataFrame ((data=res_list, columns=symbols+[total]) [303] मेंः (df/df.iloc[0,:]).plot(figsize=(15,6),grid = True); #नॉर्मलाइजेशन द्वारा ट्रेंड को प्लॉट करें बाहर[303]:img[304] मेंः (res.total/10000-(df/df.iloc[0,:]).mean(axis=1)).plot(figsize=(15,6),grid = True); #enheance प्रभाव बाहर[1]:img

कछुए की रणनीति

कछुआ रणनीति एक क्लासिक ट्रेंड रणनीति है जिसमें पदों को जोड़ने के लिए पूर्ण स्टॉप-लॉस तर्क शामिल है। विवरण के लिए, कृपया देखेंःhttps://zhuanlan.zhihu.com/p/27987938हम बैकटेस्ट के लिए यहाँ एक सरल संस्करण लागू करेंगे.

कछुए की रणनीति अवधि की रणनीति पर बहुत प्रभाव पड़ता है, और यह एक अवधि है कि बहुत कम है चुनने के लिए अनुशंसित नहीं है। यहाँ, हम 6h चुनते हैं। डोंचियन चैनल अवधि 5 के रूप में चुना जाता है, और स्थिति अनुपात बैकटेस्ट के अनुसार 0.003 के रूप में चुना जाता है। जब कीमत 1 इकाई लंबी स्थिति खोलने के लिए चैनल के अपबैंड के माध्यम से टूट जाती है, और स्थिति खोलने के बाद कीमत 0.3 अस्थिरता बढ़ती रहती है, 1 इकाई जोड़ना जारी रखें, और मूल्य 2.5 से नीचे गिर जाता है। स्टॉप लॉस के लिए नवीनतम खुली कीमत की अस्थिरता। शॉर्ट ऑर्डर का सिद्धांत समान है। ईटीएच के बड़े बुल बाजार के कारण, कछुए की रणनीति ने मुख्य प्रवृत्ति को पकड़ लिया है और अंततः अवधि के दौरान अधिकतम 4 गुना लाभ प्राप्त किया है, अधिकतम लाभ के साथ।

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

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

[424] मेंः प्रतीक = ETH df = GetKlines ((प्रतीक=प्रतीक,start=2019-8-11,end=2021-8-11,period=6h) [425 में]: df.index = pd.to_datetime ((df.time,unit=ms) [568] मेंः M = 5 # डोंचियन चैनल का अवधि खंड pct = 0.003 #जोड़े गए पदों का कुल पदों में अनुपात df[up] = df[high].rolling ((M).max().shift(1) #upBand of Donchian channel, t के माध्यम से तोड़ने के लिए लंबे और न्याय करने के लिए उपयोग किया जाता है df[down] = df[low].रोलिंग(M).मैक्स().शिफ्ट(1) df[middle] = (df[up]+df[down])/2 df[true_range] = pd.concat([df[high]-df[low],df[high]-df[close].shift(1),df[close].shift(1)-df[low],अक्ष=1).max (अक्ष=1) df[N] = df[true_range].rolling(50).mean() #N हाल की अस्थिरता के बराबर है, जिसका उपयोग खरीद और स्टॉप लॉस के लिए न्याय करने के लिए किया जाता है [572] मेंः open_times = 0.3 #पोजीशन खोलने का निर्णय stop_times = 2.5 #स्टॉप हानि e = Exchange([प्रतीक], शुल्क=0.0004, initial_balance=10000) # लेने वाले को 0.0004 पर सेट करें res_list = [] last_price = 0 #पिछली खुली स्थिति की कीमत df.iterrows में पंक्ति के लिएः कलाई = पंक्ति[1] यदि kline.isnull().sum() > 0: #डेटा के बिना अनुभाग को छोड़ दें जारी रखें इकाई = e.account[USDT][total]*pct/kline.N #open position unit amount

if kline.high >  kline.up and e.account[symbol]['amount'] == 0: #first time to open long position 
    e.Buy(symbol,kline.up,unit) #notice the trading price here
    last_price = kline.up
if e.account[symbol]['amount'] > 0 and kline.high > last_price + open_times*kline.N: #long position, buy in 
    e.Buy(symbol,last_price + open_times*kline.N,unit)
    last_price = last_price + open_times*kline.N
if e.account[symbol]['amount'] > 0 and kline.low < last_price - stop_times*kline.N: #long position, stop loss
    e.Sell(symbol,last_price - stop_times*kline.N,e.account[symbol]['amount'])
    
if kline.low <  kline.down and e.account[symbol]['amount'] == 0: #open short
    e.Sell(symbol,kline.down,unit)
    last_price = kline.down
if e.account[symbol]['amount'] < 0 and kline.low < last_price - open_times*kline.N: #short position, buy in 
    e.Sell(symbol,last_price - open_times*kline.N,unit)
    last_price = last_price - open_times*kline.N
if e.account[symbol]['amount'] < 0 and kline.high > last_price + stop_times*kline.N: #short position, stop loss
    e.Buy(symbol,last_price + stop_times*kline.N,-e.account[symbol]['amount'])
    
e.Update({symbol:kline.close})
res_list.append([kline.time, kline.close, e.account[symbol]['amount']*kline.close, e.account['USDT']['total']])

res = pd.DataFrame ((data=res_list, columns=[time,price,value,total]) res.index = pd.to_datetime ((res.time,unit=ms) print(अंतिम बाजार मूल्यः,res[कुल][-1]) आउट[572]:अंतिम बाजार मूल्यः 280760.566996 [573] मेंः res.total.plot ((figsize=(15,6), ग्रिड = सच); बाहर[573]:img[571] मेंः (res.value/res.total).plot(figsize=(15,6),ग्रिड = सच); बाहर[571]:img

निष्कर्ष

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

डेटा विश्लेषण करने के लिए पायथन का प्रयोग करेंःhttps://wizardforcel.gitbooks.io/pyda-2e/content/

पायथन मात्रात्मक ट्यूटोरियलःhttps://wizardforcel.gitbooks.io/python-quant-uqer/content/

[ ] मेंः


अधिक