शुरुआती के लिए क्रिप्टोकरेंसी मात्रात्मक व्यापार - आपको क्रिप्टोकरेंसी मात्रात्मक के करीब ले जाना (6)

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

रणनीतिक आवश्यकताओं के आधार पर डिजाइन सोच

इस लेख में, पिछले एक की तरह, फिर भी FMZ क्वांट (FMZ.COM).

• बहु-प्रजाति सीधे शब्दों में कहें तो मुझे लगता है कि यह ग्रिड रणनीति न केवलBTC_USDT, लेकिन यह भीLTC_USDT/EOS_USDT/DOGE_USDT/ETC_USDT/ETH_USDT. वैसे भी, स्पॉट ट्रेडिंग जोड़े और किस्मों है कि चलाने के लिए चाहते हैं सभी एक ही समय में ग्रिड पर कारोबार कर रहे हैं.

  यह कई प्रजातियों के अस्थिर बाजार पर कब्जा करने के लिए अच्छा लगता है। यह आवश्यकता बहुत सरल लगती है, और समस्या डिजाइन करते समय आती है।

  • 1. सबसे पहले, कई किस्मों के बाजार उद्धरण प्राप्त किए जाते हैं। यह पहली समस्या है जिसे हल किया जाना है। एक्सचेंज के एपीआई दस्तावेजों से परामर्श करने के बाद, मुझे पता चला कि अधिकांश एक्सचेंज एकत्रित बाजार इंटरफ़ेस प्रदान करते हैं। ठीक है, डेटा प्राप्त करने के लिए एकत्रित बाजार इंटरफ़ेस का उपयोग करें।
  • 2. दूसरी समस्या का सामना खाता संपत्ति है. क्योंकि यह एक बहु प्रजाति रणनीति है, यह प्रत्येक व्यापार जोड़ी संपत्ति के प्रबंधन को अलग से विचार करने के लिए आवश्यक है. और हमें एक बार में सभी संपत्ति के लिए डेटा प्राप्त करने की आवश्यकता है, और उन्हें रिकॉर्ड करें. हमें खाता संपत्ति डेटा प्राप्त करने की आवश्यकता क्यों है? हमें प्रत्येक जोड़ी के रिकॉर्ड को अलग करने की आवश्यकता क्यों है? क्योंकि आदेश देते समय आपको उपलब्ध संपत्ति का आकलन करना होता है। क्या इसे आकलन करने से पहले इसे प्राप्त करना आवश्यक है? और आप लाभ की गणना करने की जरूरत है, यह भी आवश्यक है एक प्रारंभिक खाता संपत्ति डेटा रिकॉर्ड करने के लिए पहले, तो चालू खाता संपत्ति डेटा प्राप्त और लाभ और हानि की गणना करने के लिए प्रारंभिक एक के साथ तुलना करने के लिए? सौभाग्य से, एक्सचेंज के परिसंपत्ति खाता इंटरफ़ेस आमतौर पर सभी मुद्रा परिसंपत्ति डेटा लौटाता है, हमें इसे केवल एक बार प्राप्त करने की आवश्यकता है, और फिर डेटा को संसाधित करें।
  • 3. रणनीति पैरामीटर डिजाइन. बहु प्रजातियों का पैरामीटर डिजाइन एकल-प्रजाति के पैरामीटर डिजाइन से काफी अलग है, हालांकि प्रत्येक बहु-प्रजाति की ट्रेडिंग तर्क समान है, यह संभव है कि ट्रेडिंग के दौरान पैरामीटर अलग हों। उदाहरण के लिए, ग्रिड रणनीति में, आप BTC_USDT ट्रेडिंग जोड़ी करते समय हर बार 0.01 BTC का व्यापार करना चाह सकते हैं, लेकिन DOGE_USDT करते समय इस पैरामीटर (0.01 सिक्कों का व्यापार) का उपयोग करना स्पष्ट रूप से अनुचित है। बेशक, आप USDT राशि से भी निपट सकते हैं। लेकिन फिर भी समस्याएं होंगी। क्या होगा यदि आप BTC_USDT के लिए 1000U और DOGE_USDT के लिए 10U का व्यापार करना चाहते हैं? मांग कभी भी संतुष्ट नहीं हो सकती है। कोई हो सकता है जो इस समस्या के बारे में सोचता है और फिर पूछता हैः मैं अलग-अलग व्यापारिक जोड़े के मापदंडों को नियंत्रित करने के लिए मापदंडों के कई सेट सेट कर सकता हूं। यह अभी भी जरूरतों को पूरा करने के लिए पर्याप्त लचीला नहीं है, मापदंडों के कितने सेट सेट करने के लिए अच्छा है? मापदंडों के तीन सेट सेट कर रहे हैं, क्या अगर मैं 4 किस्मों बनाना चाहते हैं? क्या मुझे रणनीति को संशोधित करने और मापदंडों को बढ़ाने की जरूरत है? इसलिए, बहु-प्रजाति रणनीति के मापदंडों को डिजाइन करते समय, ऐसे विभेदित मापदंडों की जरूरतों पर पूरी तरह से विचार करना आवश्यक है। एक समाधान मापदंडों को साधारण स्ट्रिंग या जेएसओएन स्ट्रिंग के रूप में डिजाइन करना है। उदाहरण के लिए:

    ETHUSDT:100:0.002|LTCUSDT:20:0.1
    

    उनमें से, गम प्रत्येक प्रजाति के डेटा को विभाजित करता है, जिसका अर्थ है किETHUSDT:100:0.002ETH_USDT ट्रेडिंग जोड़ी को नियंत्रित करता है, औरLTCUSDT:20:0.1LTC_USDT ट्रेडिंग जोड़ी को नियंत्रित करता है। मध्य धर्म को विभाजित करने के लिए उपयोग किया जाता है।ETHUSDT:100:0.002, जहां ETHUSDT इंगित करता है कि आप क्या व्यापार जोड़ी करना चाहते हैं, 100 ग्रिड अंतराल है, 0.002 प्रत्येक ग्रिड में कारोबार किए गए ETH सिक्कों की संख्या है, और : इन डेटा को विभाजित करना है (बेशक, ये पैरामीटर नियम रणनीति डिजाइनर द्वारा बनाए जाते हैं, आप अपनी आवश्यकताओं के अनुसार कुछ भी डिजाइन कर सकते हैं) । इन स्ट्रिंग्स में प्रत्येक प्रजाति की पैरामीटर जानकारी होती है जिसे आप करना चाहते हैं. रणनीति में इन स्ट्रिंग्स को पार्स करें, और प्रत्येक प्रजाति के ट्रेडिंग लॉजिक को नियंत्रित करने के लिए रणनीति के चर को मान असाइन करें. इसे कैसे पार्स करें? फिर भी उपरोक्त उदाहरण का उपयोग करें.

    function main() {
        var net = []  // The recorded grid parameters, use the data when running to the grid trading logic
        var params = "ETHUSDT:100:0.002|LTCUSDT:20:0.1"
        var arrPair = params.split("|")
        _.each(arrPair, function(pair) {
            var arr = pair.split(":")
            var symbol = arr[0]              // Trading pair name
            var diff = parseFloat(arr[1])    // Grid spacing
            var amount = parseFloat(arr[2])  // Grid order volume
            net.push({symbol : symbol, diff : diff, amount : amount})
        })
        Log("Grid parameter data:", net)
    }
    

    

    इस को देखते हुए, मापदंडों पार्स कर रहे हैं. बेशक, आप भी सीधे JSON स्ट्रिंग का उपयोग कर सकते हैं, जो सरल है.

    function main() {        
        var params = '[{"symbol":"ETHUSDT","diff":100,"amount":0.002},{"symbol":"LTCUSDT","diff":20,"amount":0.1}]'
        var net = JSON.parse(params)  // The recorded grid parameters, use the data when running to the grid trading logic        
        _.each(net, function(pair) {
            Log("Trading pairs:", pair.symbol, pair)
        })
    }
    

    

  • 4. डेटा स्थायित्व व्यवहार में लागू की जा सकने वाली रणनीतियों और ट्यूटोरियल रणनीतियों के बीच भी बड़ा अंतर है। पिछले लेख में ट्यूटोरियल रणनीतियाँ केवल रणनीति तर्क और डिजाइन का प्रारंभिक परीक्षण हैं, और वास्तविक दुनिया में आने पर विचार करने के लिए अधिक मुद्दे हैं। वास्तविक बॉट में, वास्तविक ट्रेडिंग शुरू करना और रोकना संभव है। इस समय, वास्तविक बॉट ऑपरेशन के दौरान सभी डेटा खो जाएंगे। तो वास्तविक बॉट को रोकने के बाद भी पिछली स्थिति में चलना जारी रखने के लिए कैसे पुनः आरंभ किया जाए? यहाँ, जब वास्तविक बॉट चल रहा है तो कुंजी डेटा को लगातार सहेजना आवश्यक है, ताकि डेटा को पढ़ा जा सके और इसे पुनरारंभ करने पर चलाना जारी रखा जा सके। आप का उपयोग कर सकते हैं_G()एफएमजेड मात्रात्मक ट्रेडिंग प्लेटफॉर्म पर फ़ंक्शन, या डेटाबेस ऑपरेशन फ़ंक्शन का उपयोग करेंDBExec(), और आप विवरण के लिए एफएमजेड एपीआई प्रलेखन की जांच कर सकते हैं।

    उदाहरण के लिए, हम एक पूंछ स्वीप समारोह डिजाइन और उपयोग_G()ग्रिड डेटा को सहेजने के लिए फ़ंक्शन।

    var net = null 
    function main() {  // Strategy main functions
        // Read the stored net first
        net = _G("net")
        
        // ...
    }
    
    function onExit() {
        _G("net", net)
        Log("Perform tail-sweeping processing and save data", "#FF0000")
    }
    
    function onexit() {    // The exit sweep function defined by the platform system, triggered the execution when the real bot is clicked to stop
        onExit()
    }
    
    function onerror() {   // The abnormal exit function defined by the platform system, triggered the execution when the program is abnormal
        onExit()
    }
    

  • 5. आदेश मात्रा सटीकता, आदेश मूल्य सटीकता, न्यूनतम आदेश मात्रा, और न्यूनतम आदेश राशि आदि जैसी सीमाएं।

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

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

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

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

टेम्पलेट वर्ग पुस्तकालय डिजाइन करें

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

हम इस टेम्पलेट वर्ग पुस्तकालय को इस तरह से डिजाइन कर सकते हैं (कोड का एक हिस्सा छोड़ दिया गया है):

function createBaseEx(e, funcConfigure) {
    var self = {}
    self.e = e 
    
    self.funcConfigure = funcConfigure
    self.name = e.GetName()
    self.type = self.name.includes("Futures_") ? "Futures" : "Spot"
    self.label = e.GetLabel()
    
    // Interfaces to be implemented
    self.interfaceGetTickers = null   // Create a function to asynchronously obtain a thread of aggregated market data
    self.interfaceGetAcc = null       // Create a function that asynchronously obtains account data thread
    self.interfaceGetPos = null       // Get a position
    self.interfaceTrade = null        // Create concurrent orders
    self.waitTickers = null           // Waiting for concurrent market data 
    self.waitAcc = null               // Waiting for account concurrent data
    self.waitTrade = null             // Waiting for order concurrent data
    self.calcAmount = null            // Calculate the order volume based on data such as trading pair accuracy
    self.init = null                  // Initialization work, obtaining data such as accuracy
    
    // Execute the configuration function to configure the object
    funcConfigure(self)

    // Check whether the interfaces agreed by configList are implemented
    _.each(configList, function(funcName) {
        if (!self[funcName]) {
            throw "interface" + funcName + "unimplemented"
        }
    })
    
    return self
}

$.createBaseEx = createBaseEx
$.getConfigureFunc = function(exName) {
    dicRegister = {
        "Futures_OKCoin" : funcConfigure_Futures_OKCoin,    // Implementation of OK futures
        "Huobi" : funcConfigure_Huobi,
        "Futures_Binance" : funcConfigure_Futures_Binance,
        "Binance" : funcConfigure_Binance,
        "WexApp" : funcConfigure_WexApp,                    // Implementation of wexApp
    }
    return dicRegister
}

टेम्पलेट में, यह विशिष्ट एक्सचेंजों के लिए लिखा गया है, एक उदाहरण के रूप में FMZ के अनुकरणीय बॉट WexApp को लेंः

function funcConfigure_WexApp(self) {
    var formatSymbol = function(originalSymbol) {
        // BTC_USDT
        var arr = originalSymbol.split("_")
        var baseCurrency = arr[0]
        var quoteCurrency = arr[1]
        return [originalSymbol, baseCurrency, quoteCurrency]
    }

    self.interfaceGetTickers = function interfaceGetTickers() {
        self.routineGetTicker = HttpQuery_Go("https://api.wex.app/api/v1/public/tickers")
    }

    self.waitTickers = function waitTickers() {
        var ret = []
        var arr = JSON.parse(self.routineGetTicker.wait()).data
        _.each(arr, function(ele) {
            ret.push({
                bid1: parseFloat(ele.buy), 
                bid1Vol: parseFloat(-1),
                ask1: parseFloat(ele.sell), 
                ask1Vol: parseFloat(-1),
                symbol: formatSymbol(ele.market)[0],
                type: "Spot", 
                originalSymbol: ele.market
            })
        })
        return ret 
    }

    self.interfaceGetAcc = function interfaceGetAcc(symbol, updateTS) {
        if (self.updateAccsTS != updateTS) {
            self.routineGetAcc = self.e.Go("GetAccount")
        }
    }

    self.waitAcc = function waitAcc(symbol, updateTS) {
        var arr = formatSymbol(symbol)
        var ret = null 
        if (self.updateAccsTS != updateTS) {
            ret = self.routineGetAcc.wait().Info
            self.bufferGetAccRet = ret 
        } else {
            ret = self.bufferGetAccRet
        }
        if (!ret) {
            return null 
        }        
        var acc = {symbol: symbol, Stocks: 0, FrozenStocks: 0, Balance: 0, FrozenBalance: 0, originalInfo: ret}
        _.each(ret.exchange, function(ele) {
            if (ele.currency == arr[1]) {
                // baseCurrency
                acc.Stocks = parseFloat(ele.free)
                acc.FrozenStocks = parseFloat(ele.frozen)
            } else if (ele.currency == arr[2]) {
                // quoteCurrency
                acc.Balance = parseFloat(ele.free)
                acc.FrozenBalance = parseFloat(ele.frozen)
            }
        })
        return acc
    }

    self.interfaceGetPos = function interfaceGetPos(symbol, price, initSpAcc, nowSpAcc) {
        var symbolInfo = self.getSymbolInfo(symbol)
        var sumInitStocks = initSpAcc.Stocks + initSpAcc.FrozenStocks
        var sumNowStocks = nowSpAcc.Stocks + nowSpAcc.FrozenStocks
        var diffStocks = _N(sumNowStocks - sumInitStocks, symbolInfo.amountPrecision)
        if (Math.abs(diffStocks) < symbolInfo.min / price) {
            return []
        }
        return [{symbol: symbol, amount: diffStocks, price: null, originalInfo: {}}]
    }

    self.interfaceTrade = function interfaceTrade(symbol, type, price, amount) {
        var tradeType = ""
        if (type == self.OPEN_LONG || type == self.COVER_SHORT) {
            tradeType = "bid"
        } else {
            tradeType = "ask"
        }
        var params = {
            "market": symbol,
            "side": tradeType,
            "amount": String(amount),
            "price" : String(-1),
            "type" : "market"
        }
        self.routineTrade = self.e.Go("IO", "api", "POST", "/api/v1/private/order", self.encodeParams(params))
    }

    self.waitTrade = function waitTrade() {
        return self.routineTrade.wait()
    }

    self.calcAmount = function calcAmount(symbol, type, price, amount) {
        // Obtain trading pair information
        var symbolInfo = self.getSymbolInfo(symbol)
        if (!symbol) {
            throw symbol + ", the trading pair information cannot be checked"
        }
        var tradeAmount = null 
        var equalAmount = null  // Number of coins recorded
        if (type == self.OPEN_LONG || type == self.COVER_SHORT) {
            tradeAmount = _N(amount * price, parseFloat(symbolInfo.pricePrecision))
            // Check the minimum trading volume
            if (tradeAmount < symbolInfo.min) {
                Log(self.name, " tradeAmount:", tradeAmount, "less than", symbolInfo.min)
                return false 
            }
            equalAmount = tradeAmount / price
        } else {
            tradeAmount = _N(amount, parseFloat(symbolInfo.amountPrecision))
            // Check the minimum trading volume
            if (tradeAmount < symbolInfo.min / price) {
                Log(self.name, " tradeAmount:", tradeAmount, "less than", symbolInfo.min / price)
                return false 
            }
            equalAmount = tradeAmount
        }
        return [tradeAmount, equalAmount]
    }

    self.init = function init() {   // Functions that deal with conditions such as accuracy automatically
        var ret = JSON.parse(HttpQuery("https://api.wex.app/api/v1/public/markets"))
        _.each(ret.data, function(symbolInfo) {
            self.symbolsInfo.push({
                symbol: symbolInfo.pair,
                amountPrecision: parseFloat(symbolInfo.basePrecision),
                pricePrecision: parseFloat(symbolInfo.quotePrecision),
                multiplier: 1,
                min: parseFloat(symbolInfo.minQty),
                originalInfo: symbolInfo
            })
        })        
    }
}

तो एक रणनीति में इस टेम्पलेट का उपयोग करना सरल हैः

function main() {
    var fuExName = exchange.GetName()
    var fuConfigureFunc = $.getConfigureFunc()[fuExName]
    var ex = $.createBaseEx(exchange, fuConfigureFunc)

    var arrTestSymbol = ["LTC_USDT", "ETH_USDT", "EOS_USDT"]
    var ts = new Date().getTime()
    
    // Test to get tickers
    ex.goGetTickers()
    var tickers = ex.getTickers()
    Log("tickers:", tickers)
    
    // Test to obtain account information
    ex.goGetAcc(symbol, ts)
    
    _.each(arrTestSymbol, function(symbol) {        
        _.each(tickers, function(ticker) {
            if (symbol == ticker.originalSymbol) {
                // print ticker data
                Log(symbol, ticker)
            }
        })

        // print asset data
        var acc = ex.getAcc(symbol, ts)
        Log("acc:", acc.symbol, acc)
    })
}

रणनीति वास्तविक बॉट

उपरोक्त टेम्पलेट के आधार पर एक रणनीति डिजाइन और लिखना बहुत सरल है। पूरी रणनीति लगभग 300+ लाइनों की है और एक डिजिटल मुद्रा स्पॉट बहु-प्रजाति ग्रिड रणनीति को लागू करती है।

यह वर्तमान में पैसा खो रहा हैT_T, स्रोत कोड फिलहाल जारी नहीं किया जाएगा।

यहाँ कुछ पंजीकरण कोड हैं, यदि आप रुचि रखते हैं, तो आप कोशिश करने के लिए wexApp का उपयोग कर सकते हैंः

Buy address: https://www.fmz.com/m/s/284507
Registration code: 
adc7a2e0a2cfde542e3ace405d216731
f5db29d05f57266165ce92dc18fd0a30
1735dca92794943ddaf277828ee04c27
0281ea107935015491cda2b372a0997d
1d0d8ef1ea0ea1415eeee40404ed09cc

200 यू से थोड़ा अधिक, जब मैंने अभी दौड़ना शुरू किया, तो मुझे एक बड़ा एकतरफा बाजार मिला, लेकिन मैं धीरे-धीरे ठीक हो गया। स्पॉट ग्रिड का सबसे बड़ा लाभ यह हैः मैं सो सकता हूं! स्थिरता खराब नहीं है. यह 27 मई के बाद से संशोधित नहीं किया गया है, और वायदा ग्रिड अस्थायी रूप से कोशिश करने की हिम्मत नहीं की है.