Diskusi tentang Desain Strategi Frekuensi Tinggi Magically Modified Profit Harvester

Diskusi tentang Desain Strategi Frekuensi Tinggi Magically Modified Profit Harvester

Dalam artikel sebelumnya, kami menganalisis ide-ide dan penerapan kode dari versi spot asli dari strategi pemanen keuntungan frekuensi tinggi.

Analisis Pengumpul Keuntungan (1) Analisis Pengumpul Keuntungan (2)

Banyak pengguna dalam lingkaran cryptocurrency kuantitatif sangat prihatin tentang strategi yang dikembangkan oleh master yang disebutcetak uang. Strategi daricetak uangDari pengamatan dan analisis banyak pengikut, dapat dilihat bahwa strategi frekuensi tinggi mirip dengan prinsip pemanen keuntungan (master Xiaocao juga mengatakan bahwa prinsip strategi frekuensi tinggi mirip dengan pemanen keuntungan).

Oleh karena itu, saya sangat bersemangat sehingga saya tidak bisa membantu tetapi ingin mengubah strategi secara ajaib, bahkan hasil dan efek strategi yang dimodifikasi secara ajaib tidak ada apa-apanya di depan strategi yang dikembangkan oleh para master.

Magically Modified Profit Harvester (Mengubah Magis Mesin Panen Keuntungan)

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 ini direncanakan untuk diperdagangkan di pasar kontrak Binance USDT, yang 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), dan Anda hanya perlu mempertimbangkan pembelian dan penjualan, tidak perlu memikirkan penutupan posisi. Cara berpikir ini juga lebih dekat dengan versi spot profit harvester.

Strategi pada dasarnya mempertahankan kriteria awal tren harga jangka pendek, dan rentang harga jangka pendek dikendalikan oleh parameterburstThresholdPctMenurut kriteria untuk menentukan apakah harga jangka pendekbullataubear.

Strategi ini menghilangkan beberapa modul dari yang asli, seperti modul saldo. modifikasi yang cukup besar adalah untuk mengubah menempatkan pesanan untuk menunggu pesanan dalam buku pesanan dan menunggu eksekusi. Diharapkan untuk membuka posisi dengan biaya yang relatif rendah di pasar yang kacau dengan permainan pendek panjang yang sengit, mengikuti tren jangka pendek, dan menutup posisi ketika tren jangka pendek berbalik, dan kemudian terus menunda pesanan dan membuka posisi sebaliknya.

Strategi ini menghilangkan kode yang tidak berguna lainnya, jadi sangat singkat dan sederhana. Meskipun strategi adalah strategi yang tidak menguntungkan, bahkan dengan kerugian, ini adalah model yang sangat mudah dan berguna bagi FMZer untuk mempelajari strategi frekuensi tinggi, mengamati tindakan strategi frekuensi tinggi, mengamati aturan mikroskopis pasar, dll. Perdagangan terprogram dan kuantitatif perlu didasarkan pada banyak praktik, pengalaman dan teori.

Jalankan di Bot

Hal ini dapat dilihat bahwa lebih sulit untuk membuka dan menutup posisi ketika situasi pasar tidak aktif.

Optimasi Strategi

Saat ini, tidak ada arah optimasi yang baik yang ditemukan. Siswa, yang tertarik, dapat berbicara secara aktif dan mendiskusikannya bersama.

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

Strategi ini hanya untuk studi; ketika pasar rata, menjalankannya di bot mungkin membuat kerugian.