के लाइन मात्रात्मक व्यापार में डेटा प्रसंस्करण कैसे करती है?

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

गैर-मानक चक्र K रेखा डेटा को छोटे चक्र के डेटा को मिलाकर प्राप्त किया जा सकता है। इसे चित्रित करें, कई चक्रों में उच्चतम मूल्य को कई चक्र K रेखा संश्लेषण के बाद उच्चतम मूल्य के रूप में गिना जाता है, और सबसे कम मूल्य को संश्लेषण के बाद सबसे कम मूल्य के रूप में गणना की जाती है, और उद्घाटन मूल्य नहीं बदलता है। K-लाइन के कच्चे माल के डेटा का पहला उद्घाटन मूल्य संश्लेषित किया जाता है। समापन मूल्य K-लाइन के अंतिम कच्चे माल के डेटा के समापन मूल्य से मेल खाता है। समय उद्घाटन मूल्य k लाइन के समय का उपयोग करता है। लेनदेन की मात्रा उस कच्चे माल के डेटा का उपयोग करती है जो योग और गणना की जाती है।

जैसा कि चित्र में दिखाया गया हैः

• विचार

चलो एक उदाहरण के रूप में ब्लॉकचेन परिसंपत्ति BTC_USDT लेते हैं और 1 घंटे को 4 घंटे में संश्लेषित करते हैं।

चार एक घंटे के चक्रों के डेटा को एक एकल चार घंटे के चक्र डेटा में मिलाया जाता है।

शुरुआती मूल्य 00:00 समय पर पहली K लाइन का शुरुआती मूल्य हैः 11382.57 समापन मूल्य 03:00: 11384.71 पर अंतिम k लाइन समापन मूल्य है उच्चतम मूल्य के लिए उनमें से उच्चतम मूल्य का पता लगाने के लिए हैः 11447.07 सबसे कम कीमत का पता लगाने के लिए उनमें से सबसे कम कीमत हैः 11365.51

नोटः चीन कमोडिटी फ्यूचर्स मार्केट सामान्य ट्रेडिंग दिन में दोपहर 3:00 बजे बंद हुआ

4-घंटे के चक्र का प्रारंभ समय पहली 1-घंटे की K-लाइन का प्रारंभ समय है, अर्थात 2019.8.12 00:00

सभी 1 घंटे k लाइन के वॉल्यूम का योग इस 4 घंटे k लाइन वॉल्यूम के रूप में उपयोग किया जाता है।

एक 4 घंटे की K-लाइन संश्लेषित की जाती हैः

High: 11447.07
Open: 11382.57
Low: 11365.51
Close: 11384.71
Time: 209.8.12 00:00

आप देख सकते हैं कि डेटा संगत है।

• कोड कार्यान्वयन

प्रारंभिक विचारों को समझने के बाद, आप आवश्यकताओं को महसूस करने के लिए मैन्युअल रूप से कोड लिख सकते हैं।

ये कोड केवल संदर्भ के लिए हैंः

function GetNewCycleRecords (sourceRecords, targetCycle) { // K line synthesis function
      var ret = []
      
      // First get the source K line data cycle
      if (!sourceRecords || sourceRecords.length < 2) {
          Return null
      }
      var sourceLen = sourceRecords.length
      var sourceCycle = sourceRecords[sourceLen - 1].Time - sourceRecords[sourceLen - 2].Time

      if (targetCycle % sourceCycle != 0) {
          Log("targetCycle:", targetCycle)
          Log("sourceCycle:", sourceCycle)
          throw "targetCycle is not an integral multiple of sourceCycle."
      }

      if ((1000 * 60 * 60) % targetCycle != 0 && (1000 * 60 * 60 * 24) % targetCycle != 0) {
          Log("targetCycle:", targetCycle)
          Log("sourceCycle:", sourceCycle)
          Log((1000 * 60 * 60) % targetCycle, (1000 * 60 * 60 * 24) % targetCycle)
          throw "targetCycle cannot complete the cycle."
      }

      var multiple = targetCycle / sourceCycle


      var isBegin = false
      var count = 0
      var high = 0
      var low = 0
      var open = 0
      var close = 0
      var time = 0
      var vol = 0
      for (var i = 0 ; i < sourceLen ; i++) {
          // Get the time zone offset value
          var d = new Date()
          var n = d.getTimezoneOffset()

          if ((1000 * 60 * 60 * 24) - sourceRecords[i].Time % (1000 * 60 * 60 * 24) + (n * 1000 * 60)) % targetCycle == 0) {
              isBegin = true
          }

          if (isBegin) {
              if (count == 0) {
                  High = sourceRecords[i].High
                  Low = sourceRecords[i].Low
                  Open = sourceRecords[i].Open
                  Close = sourceRecords[i].Close
                  Time = sourceRecords[i].Time
                  Vol = sourceRecords[i].Volume

                  count++
              } else if (count < multiple) {
                  High = Math.max(high, sourceRecords[i].High)
                  Low = Math.min(low, sourceRecords[i].Low)
                  Close = sourceRecords[i].Close
                  Vol += sourceRecords[i].Volume

                  count++
              }

              if (count == multiple || i == sourceLen - 1) {
                  Ret.push({
                      High : high,
                      Low : low,
                      Open : open,
                      Close : close,
                      Time : time,
                      Volume : vol,
                  })
                  count = 0
              }
          }
      }

      Return ret
  }

  // test
  function main () {
      while (true) {
          var r = exchange.GetRecords() // Raw data, as the basic K-line data of the synthesize K line. for example, to synthesize a 4-hour K-line, you can use the 1-hour K-line as the raw data.
          var r2 = GetNewCycleRecords(r, 1000 * 60 * 60 * 4) // Pass the original K-line data r through the GetNewCycleRecords function, and the target cycles, 1000 * 60 * 60 * 4, ie the target synthesis cycle is 4 hours K-line data .

          $.PlotRecords(r2, "r2") // The strategy class library bar can be selected by check the line class library, and calling the $.PlotRecords line drawing class library to export the function drawing.
          Sleep(1000) // Each cycle is separated by 1000 milliseconds, preventing access to the K-line interface too much, resulting in transaction restrictions.
      }
  }

वास्तव में, के लाइन संश्लेषण करने के लिए, आप दो चीजों की जरूरत है. पहला कच्चे माल डेटा है, कि एक छोटे चक्र के के लाइन डेटा है. इस उदाहरण में यह हैvar r = exchange.GetRecords()छोटे चक्र के लाइन डेटा प्राप्त करने के लिए।

दूसरा संश्लेषण चक्र का आकार पता लगाने के लिए है, हम GetNewCycleRecords फ़ंक्शन एल्गोरिथ्म का उपयोग करने के लिए यह करने के लिए, तो आप अंत में एक संश्लेषित के लाइन सरणी संरचना के डेटा वापस कर सकते हैं।

कृपया ध्यान देंः

1. लक्ष्य चक्र K रेखा के चक्र से कम नहीं हो सकता है जिसे आपने GetNewCycleRecords फ़ंक्शन में डेटा के लिए कच्चे माल के रूप में पारित किया है। क्योंकि आप एक बड़े चक्र द्वारा छोटे चक्र डेटा को संश्लेषित नहीं कर सकते हैं। केवल इसके विपरीत।

2. लक्ष्य चक्र को cycle closed पर सेट किया जाना चाहिए। cycle closed क्या है? सरल शब्दों में, एक घंटे या एक दिन के भीतर, लक्ष्य चक्र समय सीमाओं को एक बंद लूप बनाने के लिए संयुक्त किया जाता है।

उदाहरण के लिए:

12-मिनट के चक्र की के-लाइन हर घंटे 0:0 से शुरू होती है, पहला चक्र 00:00:00 ~ 00:12:00, और दूसरा चक्र 00:12: 00 ~ 00: 24:00, तीसरा चक्र 00:24: 00 ~ 00:36:00, चौथा चक्र 00:36:00 ~ 00:48:00, पांचवां चक्र 00:48 :00 ~ 01:00:00 है, जो ठीक एक पूरा हुआ एक घंटा है।

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

इसे वास्तविक बाजार में चलाएं:

कंट्रास्ट एक्सचेंज चार्ट

• के-लाइन डेटा का उपयोग करके आवश्यक डेटा संरचना का निर्माण करें

मैं सभी के लाइनों के लिए उच्चतम मूल्य के चलती औसत की गणना करना चाहते हैं. मैं क्या करना चाहिए?

आमतौर पर, हम बंद कीमतों के औसत का उपयोग करके चलती औसत की गणना करते हैं, लेकिन कभी-कभी उच्चतम मूल्य, सबसे कम मूल्य, उद्घाटन मूल्य और इतने पर का उपयोग करने की मांग होती है।

इन अतिरिक्त मांगों के लिए, एक्सचेंज.गेट रिकार्ड्स () फ़ंक्शन द्वारा लौटाए गए K लाइन डेटा को सीधे संकेतक गणना फ़ंक्शन में पारित नहीं किया जा सकता है।

उदाहरण के लिए: दtalib.MAचलती औसत संकेतक गणना कार्य में दो मापदंड हैं, पहला डेटा है जिसे पारित करने की आवश्यकता है, और दूसरा संकेतक चक्र पैरामीटर है।

उदाहरण के लिए, हमें नीचे दिखाए गए अनुसार संकेतकों की गणना करने की आवश्यकता है।

के लाइन चक्र 4 घंटे का होता है।

विनिमय बाजार उद्धरण चार्ट पर चक्र पैरामीटर 9 के साथ एक औसत रेखा निर्धारित की गई है।

गणना डेटा स्रोत प्रति बार उच्चतम मूल्य का उपयोग कर रहा है।

यही है, यह चलती औसत रेखा नौ 4-घंटे चक्र के-लाइन बार के उच्चतम औसत मूल्य के औसत से मिलकर बनती है।

चलो एक डेटा खुद को बनाने के लिए यह देखने के लिए कि क्या यह विनिमय के डेटा के साथ एक ही है.

var highs = []
for (var i = 0 ; i < r2.length ; i++) {
    highs.push(r2[i].High)
}

चूंकि हमें चलती औसत सूचक का मूल्य प्राप्त करने के लिए प्रत्येक बार के उच्चतम मूल्य की गणना करने की आवश्यकता है, इसलिए हमें एक सरणी का निर्माण करने की आवश्यकता है जिसमें प्रत्येक डेटा तत्व में प्रत्येक बार के लिए उच्चतम मूल्य है।

आप देख सकते हैं किhighsचर शुरू में एक खाली सरणी है, तो हम r2 k-लाइन डेटा चर पार (r2 याद नहीं है? ऊपर 4 घंटे के-लाइन संश्लेषित कि मुख्य समारोह में कोड देखो) ।

r2 के प्रत्येक बार की उच्चतम कीमत पढ़ें (यानी r2[i].उच्च, i 0 से r2 तक होता है. लंबाई - 1), फिर में धक्काhighs. इस तरह हम सिर्फ एक डेटा संरचना है कि के-लाइन डेटा बार के साथ एक-से-एक मेल खाता है का निर्माण.

इस समय,highsपास कर सकते हैंtalib.MAचलती औसत की गणना करने के लिए कार्य।

पूर्ण उदाहरण:

function main () {
     while (true) {
         var r = exchange.GetRecords()
         var r2 = GetNewCycleRecords(r, 1000 * 60 * 60 * 4)
         if (!r2) {
             Continue
         }
        
         $.PlotRecords(r2, "r2") // Draw the K line
        
         var highs = []
         for (var i = 0 ; i < r2.length ; i++) {
             Highs.push(r2[i].High)
         }
        
         var ma = talib.MA(highs, 9) // use the moving average function "talib.MA" to calculate the moving average indicator
         $.PlotLine("high_MA9", ma[ma.length - 2], r2[r2.length - 2].Time) // Use the line drawing library to draw the moving average indicator on the chart
        
         Sleep(1000)
     }
}

बैकटेस्टः

आप देख सकते हैं कि माउस बिंदु स्थिति के औसत संकेतक मूल्य चित्र में 11466.9289 है

उपरोक्त कोड को परीक्षण चलाने के लिए रणनीति में कॉपी किया जा सकता है, Draw Line Library की जाँच करना याद रखें और इसे सहेजें!

• क्रिप्टोक्यूरेंसी बाजार के लिए K-लाइन डेटा अधिग्रहण विधि

FMZ क्वांट प्लेटफॉर्म में पहले से ही एक पैकेज इंटरफेस है, अर्थात्exchange.GetRecordsकार्य, के-लाइन डेटा प्राप्त करने के लिए।

निम्नलिखित डेटा प्राप्त करने के लिए एक्सचेंज के के-लाइन डेटा इंटरफ़ेस के लिए प्रत्यक्ष पहुंच पर केंद्रित है, क्योंकि कभी कभी आप अधिक के लाइनों प्राप्त करने के लिए मापदंडों को निर्दिष्ट करने की आवश्यकता है, पैकेजGetRecordsइंटरफेस आम तौर पर 100 k लाइनों को लौटाता है. यदि आप एक रणनीति का सामना करते हैं जो शुरू में 100 K-लाइनों से अधिक की आवश्यकता होती है, तो आपको संग्रह प्रक्रिया की प्रतीक्षा करने की आवश्यकता है.

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

उदाहरण के रूप में Huobi एक्सचेंज पर BTC_USDT ट्रेडिंग जोड़ी का उपयोग करते हुए, हम इस आवश्यकता को लागू करते हैंः

एक्सचेंज के एपीआई दस्तावेज ढूंढें और के-लाइन इंटरफ़ेस विवरण देखें:

https://huobiapi.github.io/docs/spot/v1/en/#get-klines-candles

मापदंड:

परीक्षण कोडः

function GetRecords_Huobi (period, size, symbol) {
    var url = "https://api.huobi.pro/market/history/kline?" + "period=" + period + "&size=" + size + "&symbol=" + symbol
    var ret = HttpQuery(url)
    
    try {
        var jsonData = JSON.parse(ret)
        var records = []
        for (var i = jsonData.data.length - 1; i >= 0 ; i--) {
            records.push({
                Time : jsonData.data[i].id * 1000,
                High : jsonData.data[i].high,
                Open : jsonData.data[i].open,
                Low : jsonData.data[i].low,
                Close : jsonData.data[i].close,
                Volume : jsonData.data[i].vol,
            })
        }
        return records
    } catch (e) {
        Log(e)
    }
}  


function main() {
    var records = GetRecords_Huobi("1day", "300", "btcusdt")
    Log(records.length)
    $.PlotRecords(records, "K")
}

आप लॉग पर देख सकते हैं, प्रिंटrecords.lengthहै 300, यानी, की संख्याrecordsके लाइन डेटा बार 300 है।