Perbincangan mengenai Reka Bentuk Strategi Frekuensi Tinggi Pengumpul Keuntungan yang Dimodifikasi Ajaib

Perbincangan mengenai Reka Bentuk Strategi Frekuensi Tinggi Pengumpul Keuntungan yang Dimodifikasi Ajaib

Dalam artikel sebelumnya, kami menganalisis idea dan pelaksanaan kod versi spot asal strategi pemanen keuntungan frekuensi tinggi.

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

Ramai pengguna dalam lingkaran cryptocurrency kuantitatif sangat bimbang tentang strategi yang dibangunkan oleh seorang guru yang dipanggilcetak wang. Strategicetak wangDari pemerhatian dan analisis ramai pengikut, dapat dilihat bahawa strategi frekuensi tinggi serupa dengan prinsip pemanen keuntungan (tuhan Xiaocao juga mengatakan bahawa prinsip strategi frekuensi tinggi serupa dengan pemanen keuntungan). Tetapi mesti ada beberapa kehalusan yang membolehkan strategi mempunyai kadar kemenangan yang stabil dan nisbah keuntungan ke kerugian yang sesuai.

Oleh itu, saya sangat teruja sehingga saya tidak dapat membantu tetapi ingin mengubah strategi secara ajaib, walaupun hasil dan kesan strategi yang diubah secara ajaib tidak ada apa-apa di hadapan strategi yang dibangunkan oleh tuan. tetapi ia juga merupakan amalan pembelajaran untuk strategi frekuensi tinggi. FMZers yang berminat boleh membincangkan dan belajar mengenainya bersama-sama.

Pengumpul Keuntungan yang Dimodifikasi secara 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)
    }
}

Idea Pengubahsuaian

Strategi ini dirancang untuk berdagang di pasaran kontrak Binance USDT, yang menyokong kedudukan satu hala. Oleh itu, strategi diubah suai dan direka mengikut ciri-ciri kedudukan satu hala (kedudukan satu hala lebih mudah untuk pengubahsuaian strategi), dan anda hanya perlu mempertimbangkan membeli dan menjual, tidak perlu memikirkan kedudukan penutupan. Cara berfikir ini juga lebih dekat dengan versi spot pemanen keuntungan.

Strategi pada dasarnya mengekalkan kriteria awal trend harga jangka pendek, dan julat harga jangka pendek dikawal oleh parameterburstThresholdPctMenurut kriteria untuk menentukan sama ada harga jangka pendek adalahbullataubear.

Strategi ini mengeluarkan beberapa modul dari asal, seperti modul baki. Satu pengubahsuaian yang cukup besar adalah untuk menukar meletakkan pesanan untuk menunggu pesanan dalam buku pesanan dan menunggu pelaksanaan. Ia dijangka membuka kedudukan dengan kos yang agak rendah di pasaran huru-hara dengan permainan pendek panjang yang sengit, mengikuti trend jangka pendek, dan menutup kedudukan apabila trend jangka pendek berbalik, dan kemudian terus menunggu pesanan dan membuka kedudukan sebaliknya.

Walaupun strategi adalah strategi yang tidak menguntungkan, walaupun dengan kerugian, ia adalah model yang sangat mudah dan berguna untuk seorang FMZer untuk mempelajari strategi frekuensi tinggi, memerhatikan tindakan strategi frekuensi tinggi, memerhatikan peraturan mikroskopik pasaran, dll. Perdagangan terprogram dan kuantitatif perlu berdasarkan banyak amalan, pengalaman dan teori.

Jalankan dalam Bot

Ia dapat dilihat bahawa lebih sukar untuk membuka dan menutup kedudukan apabila keadaan pasaran tidak aktif.

Pengoptimuman Strategi

Pada masa ini, tiada arah pengoptimuman yang baik telah dijumpai. Pelajar, yang berminat, boleh bercakap secara aktif dan membincangkannya bersama.

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

Strategi ini hanya untuk kajian; apabila pasaran rata, menjalankan ia dalam bot mungkin membuat kerugian.