संशोधित लीक हार्वेस्टर के परिप्रेक्ष्य से उच्च आवृत्ति रणनीति डिजाइन पर चर्चा

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

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

संशोधित लीक हार्वेस्टर


            
            
            
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(भालू)।

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

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