लीक्सरीपर के जादू परिवर्तन से उच्च आवृत्ति रणनीति डिजाइन का अन्वेषण करें

पिछले लेखों में, हमने मूल स्पॉट संस्करण लीक्सरीपर की उच्च आवृत्ति रणनीति के विचार और कोड कार्यान्वयन का विश्लेषण किया है।

लीक्सरीपर रणनीति विश्लेषणhttps://www.fmz.com/bbs-topic/9725) लीक्सरीपर रणनीति विश्लेषण (2)https://www.fmz.com/bbs-topic/9733）

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

इसलिए, मैं मदद नहीं कर सकता था लेकिन जादू परिवर्तन करने के लिए। हालांकि जादू परिवर्तन की रणनीति प्रभाव नेताओं की रणनीतियों की तुलना में बहुत बुरा था। यह भी उच्च आवृत्ति रणनीतियों के लिए एक सीखने का अभ्यास है। FMZer में रुचि रखने वाले एक साथ चर्चा और सीखेंगे।

जादू परिवर्तन के बाद लीक्सरिपर

var TickInterval = 100

function LeeksReaper() {
    var self = {}
    self.numTick = 0
    self.lastTradeId = 0
    self.vol = 0
    self.askPrice = 0
    self.bidPrice = 0
    self.orderBook = {
        Asks: [],
        Bids: []
    }
    self.prices = []
    self.tradeOrderId = 0
    self.account = null
    self.buyPrice = 0
    self.sellPrice = 0
    self.state = 0
    self.depth = null

    self.updateTrades = function() {
        var trades = _C(exchange.GetTrades)
        if (self.prices.length == 0) {
            while (trades.length == 0) {
                trades = trades.concat(_C(exchange.GetTrades))
            }
            for (var i = 0; i < 15; i++) {
                self.prices[i] = trades[trades.length - 1].Price
            }
        }
        self.vol = 0.7 * self.vol + 0.3 * _.reduce(trades, function(mem, trade) {
            // Huobi not support trade.Id
            if ((trade.Id > self.lastTradeId) || (trade.Id == 0 && trade.Time > self.lastTradeId)) {
                self.lastTradeId = Math.max(trade.Id == 0 ? trade.Time : trade.Id, self.lastTradeId)
                mem += trade.Amount
            }
            return mem
        }, 0)

    }
    self.updateOrderBook = function() {
        var orderBook = _C(exchange.GetDepth)
        self.depth = orderBook
        self.buyPrice = orderBook.Bids[pendingLevel].Price
        self.sellPrice = orderBook.Asks[pendingLevel].Price
        self.orderBook = orderBook
        if (orderBook.Bids.length < 3 || orderBook.Asks.length < 3) {
            return
        }
        self.bidPrice = orderBook.Bids[0].Price * 0.618 + orderBook.Asks[0].Price * 0.382 + 0.01
        self.askPrice = orderBook.Bids[0].Price * 0.382 + orderBook.Asks[0].Price * 0.618 - 0.01
        self.prices.shift()
        self.prices.push(_N((orderBook.Bids[0].Price + orderBook.Asks[0].Price) * 0.15 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.1 +
            (orderBook.Bids[3].Price + orderBook.Asks[3].Price) * 0.075 +
            (orderBook.Bids[4].Price + orderBook.Asks[4].Price) * 0.05 +
            (orderBook.Bids[5].Price + orderBook.Asks[5].Price) * 0.025))
    }

    self.updateAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        LogProfit(parseFloat(account.Info.totalWalletBalance), account)
    }

    self.CancelAll = function() {
        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)
            }
            Sleep(100)
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        var pos = _C(exchange.GetPosition)

        var burstPrice = self.prices[self.prices.length - 1] * burstThresholdPct
        var bull = false
        var bear = false
        LogStatus(_D(), "\n", 'Tick:', self.numTick, 'self.vol:', self.vol, ', lastPrice:', self.prices[self.prices.length - 1], ', burstPrice: ', burstPrice)

        if (self.numTick > 2 && (
                self.prices[self.prices.length - 1] - _.max(self.prices.slice(-6, -1)) > burstPrice ||
                self.prices[self.prices.length - 1] - _.max(self.prices.slice(-6, -2)) > burstPrice && self.prices[self.prices.length - 1] > self.prices[self.prices.length - 2]
            )) {
            bull = true
        } else if (self.numTick > 2 && (
                self.prices[self.prices.length - 1] - _.min(self.prices.slice(-6, -1)) < -burstPrice ||
                self.prices[self.prices.length - 1] - _.min(self.prices.slice(-6, -2)) < -burstPrice && self.prices[self.prices.length - 1] < self.prices[self.prices.length - 2]
            )) {
            bear = true            
        }

        if (pos.length != 0) {
            if (pos[0].Type == PD_LONG) {
                self.state = 1
            } else {
                self.state = 2
            }
        } else {
            self.state = 0
        }


        if ((!bull && !bear)) {
            return
        }

        if (bull) {
            var price = (self.state == 0 || self.state == 1) ? self.buyPrice : self.depth.Bids[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 1) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("buy")
            exchange.Buy(price, amount)
        } else if (bear) {
            var price = (self.state == 0 || self.state == 2) ? self.sellPrice : self.depth.Asks[coverPendingLevel].Price
            var amount = (self.state == 0 || self.state == 2) ? pendingAmount : pos[0].Amount
            exchange.SetDirection("sell")
            exchange.Sell(price, amount)                    
        }
        self.numTick = 0
        Sleep(TickInterval)
        self.CancelAll()
        self.updateAccount()
    }

    while (!self.account) {
        self.updateAccount()
        Sleep(500)
    }
    Log("self.account:", self.account)

    return self
}

function main() {
    LogProfitReset()
    exchange.SetPrecision(pricePrecision, amountPrecision)
    exchange.SetContractType("swap")
    var reaper = LeeksReaper()  
    while (true) {
        reaper.poll()
        Sleep(100)
    }
}

रणनीति संशोधन का विचार

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

यह रणनीति मूल रूप से अल्पकालिक मूल्य प्रवृत्ति के मूल मानदंड को बरकरार रखती है, जिसे पैरामीटर द्वारा नियंत्रित किया जाता है।burstThresholdPCT, जिसके आधार पर यह आकलन किया जा सकता है कि क्या अल्पकालिक मूल्यbullयाbear.

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

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

रणनीति अनुकूलन

वर्तमान में अनुकूलन के लिए कोई अच्छी दिशा नहीं मिली है। कोई दिलचस्पी रखने वाला आपकी टिप्पणी छोड़ सकता है और साथ में चर्चा कर सकता है।

रणनीतिःhttps://www.fmz.com/strategy/260806

यह रणनीति केवल सीखने के लिए है, असली बॉट को नुकसान हो सकता है जब बाजार बहुत आशावादी नहीं होता है।