Rancangan strategi frekuensi tinggi dari mesin pemetik lobak Magic

Rancangan strategi frekuensi tinggi dari mesin pemetik lobak Magic

Dalam beberapa artikel sebelum ini, kami telah menganalisis idea dan pelaksanaan kod untuk strategi frekuensi tinggi untuk mesin pemetik ketumbar versi asli.

Penggambaran teknik mesin pemetik lobak (1) Penggambaran teknik mesin pemetik ketumbar (2)

Banyak pengguna yang lebih berminat dengan pengukuran lingkaran wang.cetak wangTaktik yang digunakan oleh orang ramai.cetak wangStrategi yang digunakan adalah perdagangan kontrak USDT. Dari pemerhatian dan analisis ramai peminat, strategi frekuensi tinggi ini menyerupai mesin pemetik lobak (Grassin juga mengatakan bahawa prinsip strategi frekuensi tinggi lebih hampir). Tetapi pasti ada kesukaran untuk mencapai strategi yang mempunyai kadar kemenangan yang stabil dan nisbah kerugian yang sesuai.

Oleh itu, kanak-kanak yang mahir dalam teknik tidak dapat menahan diri untuk mengubah sihir, walaupun kesan strategi yang diubah oleh sihir telah ditekan menjadi sampah oleh taktik dewa-dewa besar. Tetapi juga merupakan amalan pembelajaran untuk strategi frekuensi tinggi, rakan sekelas FM Zer yang berminat boleh datang bersama untuk meneroka, belajar.

Mesin pemetik lobak yang telah diubahsuai

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

Strategi mengubah pemikiran

Strategi ini dirancang untuk digunakan untuk berdagang di pasaran kontrak USDT Binance, kontrak Binance menyokong pegangan satu arah. Oleh itu, strategi ini diubah reka bentuk mengikut ciri pegangan satu arah (penguatan strategi yang lebih mudah untuk pegangan satu arah), tidak mempertimbangkan pegangan, hanya mempertimbangkan membeli dan menjual.

Strategi ini sebahagian besarnya mengekalkan kriteria penentuan trend harga jangka pendek asal, dan lebar harga jangka pendek dipengaruhi oleh parameter.burstThresholdPctPengendalian, berdasarkan kriteria ini untuk menilai harga jangka pendek adalahbull(Sapi) ataubear(Beruang)

Kaedah ini menghilangkan beberapa modul dalam versi asal, seperti modul imbangan. Perubahan yang lebih besar adalah mengubah pesanan bawah untuk meletakkan pesanan di dalam lembaran pesanan, menunggu transaksi. Menjangkakan untuk membuka dagangan dengan kos yang lebih rendah dalam peredaran huru-hara, mengikuti trend jangka pendek, dan menghampiri ketika trend jangka pendek berbalik, terus membuka dagangan secara berbalik.

Strategi ini adalah sangat ringkas dan mudah. Walaupun strategi ini adalah strategi yang tidak menghasilkan wang atau bahkan kehilangan wang, tetapi sebagai FMZer, belajar strategi frekuensi tinggi, melihat tingkah laku strategi frekuensi tinggi, melihat undang-undang mikro pasaran dan lain-lain adalah model yang boleh digunakan. Perdagangan terprogram, perdagangan kuantitatif memerlukan banyak amalan, pengalaman, teori sebagai asas.

Pergilah sebentar.

Seperti yang dapat dilihat, ia lebih sukar untuk membuka kedudukan ketika pasaran tidak aktif.

Pengoptimuman Strategi

Pada masa ini, tidak ada arah pengoptimuman yang baik. Pelajar-pelajar yang berminat boleh bersuara dan membincangkannya bersama-sama.

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

Strategi ini hanya digunakan untuk belajar, dan jika pasaran tidak stabil, ia boleh menyebabkan kerugian.