Erforschen Sie das Hochfrequenz-Strategie-Design von der magischen Veränderung von LeeksReaper

In früheren Artikeln haben wir die Idee und die Code-Implementierung der Hochfrequenzstrategie der ursprünglichen Spot-Version LeeksReaper analysiert.

Strategieanalyse von LeeksReaperhttps://www.fmz.com/bbs-topic/9725) LeeksReaper Strategie Analysehttps://www.fmz.com/bbs-topic/9733）

Viele Nutzer der digitalen Währung achten mehr auf die Strategie des Printmoney-Führers. Die Strategie des Printmoney-Führers wird im Binance USDT-Kontrakt gehandelt. Aus Beobachtung und Analyse vieler Anhänger lässt sich erkennen, dass diese Hochfrequenzstrategie dem Prinzip von LeeksReaper ähnelt (Führer Xiaocao sagte auch, dass das Prinzip der Hochfrequenzstrategien ähnlich ist). Aber es muss etwas Subtiles geben, um eine stabile Gewinnrate und ein angemessenes Gewinn-Verlust-Verhältnis zu erzielen.

Daher konnte ich nicht umhin, die magische Veränderung zu machen. Obwohl die Strategiewirkung der magischen Veränderung viel schlimmer war als die Strategien der Führer. Es ist auch eine Lernpraxis für Hochfrequenzstrategien. FMZer, die daran interessiert sind, werden gemeinsam diskutieren und lernen.

LeeksReaper nach der magischen Veränderung.

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

Die Idee der Strategieänderung

Die Strategie besteht darin, den Handel auf dem Binance USDT-Kontraktmarkt zu planen, der einseitige Positionen unterstützt. Daher wird die Strategie entsprechend den Eigenschaften einer einseitigen Position geändert (einseitige Position ist bequemer, um die Strategie zu ändern), wir ziehen nicht in Betracht, die Position zu schließen, wir betrachten nur den Verkauf und Kauf. Die Idee ist der Spot-Version des LeeksReaper näher.

Die Strategie behält grundsätzlich das ursprüngliche Kriterium des kurzfristigen Preistrenddurchbruchs bei, der durch den ParameterburstThresholdPCT, nach denen zu beurteilen ist, ob der kurzfristige Preisbulloderbear.

Die Strategie eliminiert einige der ursprünglichen Module, wie z. B. das Bilanzmodul. Es wird erwartet, dass eine Position zu einem niedrigeren Preis in einem chaotischen Long/Short-Spiel eröffnet, dem kurzfristigen Trend folgt und die Position schließt, wenn sich der kurzfristige Trend umkehrt, und die Position mit einem umgekehrten ausstehenden Auftrag weiter eröffnet wird.

Die Strategie ist kurz und einfach, weil es andere nutzlose Code entfernt. Obwohl Strategie ist eine Strategie, die kein Geld verdient, oder sogar Geld verlieren, aber als FMZer, die Hochfrequenz-Strategie lernen, beobachten das Verhalten der Hochfrequenz-Strategie, beobachten die Mikro-Gesetze des Marktes ist ein Modell, das verwendet werden kann. Programm Handel und quantitative Handel brauchen eine Menge Praxis, Erfahrung, Theorie als Grundlage.

Optimierung der Strategie

Derzeit ist keine gute Optimierungsrichtung gefunden worden. Jemand, der interessiert ist, kann Ihre Kommentare hinterlassen und gemeinsam diskutieren.

Strategie von:https://www.fmz.com/strategy/260806

Diese Strategie ist nur zum Lernen, der echte Bot kann Verluste haben, wenn der Markt nicht sehr optimistisch ist.