उच्च आवृत्ति रणनीति डिजाइन पर चर्चा जादुई रूप से संशोधित लाभ कटाई

उच्च आवृत्ति रणनीति डिजाइन पर चर्चा जादुई रूप से संशोधित लाभ कटाई

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

मुनाफा कटाईकर्ता विश्लेषण (1) मुनाफा कटाईकर्ता विश्लेषण (2)

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

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

जादुई रूप से संशोधित लाभ कटाई मशीन

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

रणनीति केवल अध्ययन के लिए है; जब बाजार फ्लैट होता है, तो इसे बॉट में चलाने से नुकसान हो सकता है।