Membahas desain strategi frekuensi tinggi dari perspektif pemanen daun bawang yang dimodifikasi

Pada artikel sebelumnya, kami menganalisis ide dan implementasi kode versi spot asli dari strategi frekuensi tinggi pemanen daun bawang.

Analisis Strategi Pemanen Daun Bawang (1)
Analisis Strategi Pemanen Daun Bawang (2)

Banyak pengguna lingkaran koin lebih peduli tentangprint moneyStrategi bos,print moneyStrategi bos adalah memperdagangkan kontrak USDT di Binance. Dari pengamatan dan analisis banyak pengikut, dapat dilihat bahwa strategi frekuensi tinggi ini mirip dengan prinsip pemanen daun bawang (Cao Shen juga mengatakan bahwa prinsip strategi frekuensi tinggi relatif dekat). Tetapi pasti ada hal-hal halus yang dapat memastikan bahwa strategi tersebut memiliki tingkat kemenangan yang stabil dan rasio untung rugi yang tepat.

Jadi sang editor yang sudah gatal ingin menunjukkan keahliannya, tak dapat menahan diri untuk melakukan beberapa modifikasi, meski efek strategi yang dimodifikasi itu hancur menjadi abu oleh strategi para master. Namun, ini juga dapat dianggap sebagai pembelajaran dan praktik strategi frekuensi tinggi. FMZers yang tertarik dapat berdiskusi dan belajar bersama.

Pemanen daun bawang yang dimodifikasi

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

Ide modifikasi strategi

Strateginya adalah merencanakan untuk menggunakan perdagangan di pasar kontrak Binance USDT. Kontrak Binance mendukung posisi satu arah. Oleh karena itu, strategi dimodifikasi dan dirancang sesuai dengan karakteristik posisi satu arah (posisi satu arah lebih nyaman untuk modifikasi strategi), tanpa mempertimbangkan penutupan posisi, hanya mempertimbangkan pembelian dan penjualan. Ide ini lebih dekat dengan versi spot pemetik daun bawang.

Strategi ini pada dasarnya mempertahankan kriteria penilaian terobosan tren harga jangka pendek asli, dan kisaran terobosan harga jangka pendek ditentukan oleh parameterburstThresholdPctKontrol, menurut kondisi penilaian ini, harga jangka pendek adalahbull(sapi), ataubear(Beruang).

Strategi ini menghapus beberapa modul dari versi asli, seperti modul keseimbangan. Perubahan terbesarnya adalah urutannya diubah menjadi menempatkan pesanan di buku pesanan dan menunggu transaksi.
Diharapkan untuk membuka posisi dengan biaya lebih rendah di pasar yang kacau di mana permainan panjang dan pendek sengit, mengikuti tren jangka pendek, menutup posisi ketika tren jangka pendek berbalik, dan terus membuka posisi dengan perintah terbalik .

Strategi ini menghilangkan kode-kode lain yang tidak berguna sehingga sangat singkat dan sederhana. Meskipun strategi tersebut tidak menguntungkan dan bahkan merugi, ini merupakan model yang dapat digunakan oleh FMZers untuk mempelajari strategi frekuensi tinggi, mengamati perilaku strategi frekuensi tinggi, dan mengamati hukum mikro pasar. Perdagangan algoritmik dan perdagangan kuantitatif memerlukan banyak praktik, pengalaman, dan teori sebagai dasar.

Lari sebentar

Dapat dilihat bahwa lebih sulit untuk membuka dan menutup posisi ketika pasar tidak aktif.

Optimasi Strategi

Saat ini, belum ditemukan arah pengoptimalan yang baik.
Siswa yang berminat dipersilakan untuk berbicara dan berdiskusi bersama.

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

Strategi ini hanya untuk tujuan pembelajaran, dan perdagangan sebenarnya dapat mengakibatkan kerugian jika pasar datar.