Jelajahi Desain Strategi Frekuensi Tinggi dari Magic Change of LeeksReaper

Dalam artikel sebelumnya, kami telah menganalisis ide dan implementasi kode strategi frekuensi tinggi dari versi spot asli LeeksReaper.

Analisis Strategi LeeksReaperhttps://www.fmz.com/bbs-topic/9725) Analisis Strategi LeeksReaperhttps://www.fmz.com/bbs-topic/9733）

Banyak pengguna mata uang digital lebih memperhatikan strategi pemimpin uang cetak. Strategi pemimpin uang cetak diperdagangkan dalam kontrak Binance USDT. Dari pengamatan dan analisis banyak pengikut dapat dilihat bahwa strategi frekuensi tinggi ini mirip dengan prinsip LeeksReaper (pemimpin Xiaocao juga mengatakan bahwa prinsip strategi frekuensi tinggi serupa).

Oleh karena itu, saya tidak bisa membantu tetapi membuat perubahan sihir. Meskipun efek strategi dari perubahan sihir jauh lebih buruk daripada strategi para pemimpin. Ini juga merupakan praktik belajar untuk strategi frekuensi tinggi. FMZer yang tertarik akan mendiskusikan dan belajar bersama-sama.

LeeksReaper setelah perubahan ajaib

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)
    }
}

Gagasan modifikasi strategi

Strategi ini adalah untuk merencanakan perdagangan di pasar kontrak Binance USDT, yang mendukung posisi satu arah. Oleh karena itu, strategi dimodifikasi sesuai dengan karakteristik posisi satu arah (posisi satu arah lebih nyaman untuk memodifikasi strategi), kami tidak mempertimbangkan penutupan posisi, kami hanya mempertimbangkan jual beli. Ide ini lebih dekat dengan versi spot LeeksReaper.

Strategi pada dasarnya mempertahankan kriteria asli terobosan tren harga jangka pendek, yang dikendalikan oleh parameterburstThresholdPCT, untuk menilai apakah harga jangka pendekbullataubear.

Strategi ini menghilangkan beberapa modul asli, seperti modul saldo. Perubahan yang lebih besar adalah pembuat di buku pesanan, menunggu transaksi. Hal ini diharapkan adalah untuk membuka posisi dengan biaya yang lebih rendah dalam permainan panjang/pendek yang kacau, mengikuti tren jangka pendek, dan menutup posisi ketika tren jangka pendek berbalik dan terus membuka posisi dengan perintah menunggu terbalik.

Strategi ini singkat dan sederhana karena menghapus kode yang tidak berguna lainnya. Meskipun strategi adalah strategi yang tidak menghasilkan uang, atau bahkan kehilangan uang, tetapi sebagai FMZer yang belajar strategi frekuensi tinggi, mengamati perilaku strategi frekuensi tinggi, mengamati hukum mikro pasar adalah model yang dapat digunakan. Perdagangan program dan perdagangan kuantitatif membutuhkan banyak latihan, pengalaman, teori sebagai dasar.

Optimasi Strategi

Saat ini, tidak ada arah yang baik untuk optimasi. Seseorang yang tertarik dapat meninggalkan komentar Anda dan mendiskusikannya bersama.

Strategi dari:https://www.fmz.com/strategy/260806

Strategi ini hanya untuk belajar, bot nyata mungkin memiliki kerugian ketika pasar tidak terlalu optimis.