dYdX रणनीति डिजाइन का उदाहरण

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

स्टोकैस्टिक ट्रेडिंग रणनीति डिजाइन

चलो एक ब्रेनस्टॉर्म करते हैं! यह यादृच्छिक संकेतकों और कीमतों के साथ यादृच्छिक रूप से आदेश रखने की एक रणनीति डिजाइन करने की योजना है। आदेश रखने के लिए संभावना पर दांव लगाते हुए लंबे या छोटे जाने से ज्यादा कुछ नहीं है। फिर हम यह निर्धारित करने के लिए यादृच्छिक संख्या 1 ~ 100 का उपयोग करेंगे कि लंबे या छोटे जाने के लिए।

लंबी अवधि के लिए शर्तः यादृच्छिक संख्या 1~50. शॉर्ट के लिए शर्तः यादृच्छिक संख्या 51~100।

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

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

ठीक है, रणनीति सरल रूप से तैयार की गई है।

स्रोत कोड डिजाइन किया गयाः

var openPrice = 0 
var ratio = 1
var totalEq = null 
var nowEq = null 

function cancelAll() {
    while (1) {
        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            break
        }
        for (var i = 0 ; i < orders.length ; i++) {
            exchange.CancelOrder(orders[i].Id, orders[i])
            Sleep(500)
        }
        Sleep(500)
    }
}

function main() {
    if (isReset) {
        _G(null)
        LogReset(1)
        LogProfitReset()
        LogVacuum()
        Log("reset all data", "#FF0000")
    }

    exchange.SetContractType(ct)

    var initPos = _C(exchange.GetPosition)
    if (initPos.length != 0) {
        throw "Strategy starts with a position!"
    }
    
    exchange.SetPrecision(pricePrecision, amountPrecision)
    Log("set the pricePrecision", pricePrecision, amountPrecision)
    
    if (!IsVirtual()) {
        var recoverTotalEq = _G("totalEq")
        if (!recoverTotalEq) {
            var currTotalEq = _C(exchange.GetAccount).Balance   // equity
            if (currTotalEq) {
                totalEq = currTotalEq
                _G("totalEq", currTotalEq)
            } else {
                throw "failed to obtain initial interest"
            }
        } else {
            totalEq = recoverTotalEq
        }
    } else {
        totalEq = _C(exchange.GetAccount).Balance
    }
    
    while (1) {
        if (openPrice == 0) {
            // Update account information and calculate profits
            var nowAcc = _C(exchange.GetAccount)
            nowEq = IsVirtual() ? nowAcc.Balance : nowAcc.Balance  // equity
            LogProfit(nowEq - totalEq, nowAcc)
            
            var direction = Math.floor((Math.random()*100)+1)   // 1~50 , 51~100
            var depth = _C(exchange.GetDepth)
            if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                Sleep(1000)
                continue 
            }
            if (direction > 50) {
                // long
                openPrice = depth.Bids[1].Price
                exchange.SetDirection("buy")
                exchange.Buy(Math.abs(openPrice) + slidePrice, amount * ratio)
            } else {
                // short
                openPrice = -depth.Asks[1].Price
                exchange.SetDirection("sell")
                exchange.Sell(Math.abs(openPrice) - slidePrice, amount * ratio)
            }       
            Log("place", direction > 50 ? "buying order" : "selling order", ", price:", Math.abs(openPrice))
            continue
        }

        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            var pos = _C(exchange.GetPosition)
            if (pos.length == 0) {
                openPrice = 0
                continue
            }
            
            // Test for closing the position
            while (1) {
                var depth = _C(exchange.GetDepth)
                if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                    Sleep(1000)
                    continue 
                }
                var stopLossPrice = openPrice > 0 ? Math.abs(openPrice) - stopLoss : Math.abs(openPrice) + stopLoss 
                var stopProfitPrice = openPrice > 0 ? Math.abs(openPrice) + stopProfit : Math.abs(openPrice) - stopProfit
                var winOrLoss = 0 // 1 win , -1 loss 
                
                // drawing the line
                $.PlotLine("bid", depth.Bids[0].Price)
                $.PlotLine("ask", depth.Asks[0].Price)
                
                // stop loss
                if (openPrice > 0 && depth.Bids[0].Price < stopLossPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)
                    winOrLoss = -1
                } else if (openPrice < 0 && depth.Asks[0].Price > stopLossPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = -1
                }
                
                // stop profit
                if (openPrice > 0 && depth.Bids[0].Price > stopProfitPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)  
                    winOrLoss = 1
                } else if (openPrice < 0 && depth.Asks[0].Price < stopProfitPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = 1
                }
                
                // Test the pending orders
                Sleep(2000)
                var orders = _C(exchange.GetOrders)                
                if (orders.length == 0) {
                    pos = _C(exchange.GetPosition)
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }                    
                } else {
                    // cancel pending orders
                    cancelAll()
                    Sleep(2000)
                    pos = _C(exchange.GetPosition)
                    // update the position after cancellation, and check it again
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }    
                }
                
                var tbl = {
                    "type" : "table", 
                    "title" : "info", 
                    "cols" : ["totalEq", "nowEq", "openPrice", "bid1Price", "ask1Price", "ratio", "pos.length"], 
                    "rows" : [], 
                }
                tbl.rows.push([totalEq, nowEq, Math.abs(openPrice), depth.Bids[0].Price, depth.Asks[0].Price, ratio, pos.length])
                tbl.rows.push(["pos", "type", "amount", "price", "--", "--", "--"])
                for (var j = 0 ; j < pos.length ; j++) {
                    tbl.rows.push([j, pos[j].Type, pos[j].Amount, pos[j].Price, "--", "--", "--"])
                }
                LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
            }
        } else {
            // cancel the pending orders
            // reset openPrice
            cancelAll()
            openPrice = 0
        }
        Sleep(1000)
    }
}

रणनीतिक मापदंडः

ओह हाँ! रणनीति को एक नाम की आवश्यकता है, चलो इसे अनुमानित करें आकार (dYdX संस्करण) कहते हैं।

बैकटेस्ट

बैकटेस्टिंग केवल संदर्भ के लिए है, >_

बैकटेस्ट पूरा हो गया है, कोई बग नहीं है।

इस रणनीति का उपयोग केवल सीखने और संदर्भ के लिए किया जाता है, इसका उपयोग वास्तविक बॉट में न करें!