Membincangkan reka bentuk strategi frekuensi tinggi dari perspektif penuai daun bawang yang diubah suai

Dalam artikel sebelumnya, kami menganalisis idea dan pelaksanaan kod versi spot asal strategi frekuensi tinggi penuai daun bawang.

Analisis Strategi Penuai Leek (1) Analisis Strategi Penuai Leek (2)

Ramai pengguna kuantifikasi bulatan mata wang lebih mengambil berat tentangprint moneyStrategi bos,print moneyStrategi bos adalah untuk berdagang kontrak USDT di Binance. Daripada pemerhatian dan analisis oleh ramai pengikut, dapat dilihat bahawa strategi frekuensi tinggi ini adalah serupa dengan prinsip penuai daun bawang (Cao Shen juga mengatakan bahawa prinsip strategi frekuensi tinggi adalah agak rapat). Tetapi pastinya terdapat kehalusan yang boleh memastikan bahawa strategi mempunyai kadar kemenangan yang stabil dan nisbah untung dan rugi yang sesuai.

Jadi editor yang gatal untuk menunjukkan kemahirannya tidak dapat membantu tetapi membuat beberapa pengubahsuaian, walaupun kesan strategi yang diubah suai itu dihancurkan oleh strategi tuan. Tetapi ia juga boleh dianggap sebagai pembelajaran dan amalan strategi frekuensi tinggi FMZ yang Berminat boleh berbincang dan belajar bersama.

Penuai daun bawang yang diubah suai

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

Idea pengubahsuaian strategi

Strateginya adalah untuk merancang untuk menggunakan dagangan dalam pasaran kontrak Binance USDT Kontrak Binance menyokong kedudukan sehala. Oleh itu, strategi diubah suai dan direka mengikut ciri-ciri kedudukan sehala (kedudukan sehala lebih mudah untuk pengubahsuaian strategi), tanpa mengambil kira kedudukan penutup, hanya mempertimbangkan pembelian dan penjualan. Idea ini lebih dekat dengan versi spot penuai daun bawang.

Strategi ini pada asasnya mengekalkan kriteria pertimbangan penembusan arah aliran harga jangka pendek asal, dan julat penembusan harga jangka pendek ditentukan oleh parameterburstThresholdPctKawalan, mengikut syarat penghakiman ini, harga jangka pendek adalahbull(lembu), ataubear(Beruang).

Strategi ini mengalih keluar beberapa modul daripada versi asal, seperti modul baki. Perubahan terbesar ialah pesanan telah ditukar kepada meletakkan pesanan dalam buku pesanan dan menunggu transaksi. Ia dijangka membuka kedudukan pada kos yang lebih rendah dalam pasaran yang huru-hara di mana permainan panjang dan pendek adalah sengit, mengikuti arah aliran jangka pendek, menutup kedudukan apabila arah aliran jangka pendek berbalik, dan terus membuka kedudukan dengan pesanan terbalik .

Strategi ini mengalih keluar kod lain yang tidak berguna jadi ia sangat pendek dan mudah. Walaupun strategi itu tidak menguntungkan malah kehilangan wang, ia adalah model yang boleh digunakan oleh FMZers untuk mempelajari strategi frekuensi tinggi, memerhati tingkah laku strategi frekuensi tinggi, dan memerhatikan undang-undang mikro pasaran. Perdagangan algoritma dan perdagangan kuantitatif memerlukan banyak latihan, pengalaman, dan teori sebagai asas.

Lari sekejap

Ia boleh dilihat bahawa lebih sukar untuk membuka dan menutup posisi apabila pasaran tidak aktif.

Pengoptimuman Strategi

Pada masa ini, tiada arah pengoptimuman yang baik ditemui. Pelajar yang berminat dialu-alukan untuk bersuara dan berbincang bersama.

Alamat strategi: https://www.fmz.com/strategy/260806

Strategi ini hanya untuk tujuan pembelajaran, dan perdagangan sebenar boleh mengakibatkan kerugian jika pasaran tidak berubah.