Diskussion über die Gestaltung von Hochfrequenzstrategien aus der Perspektive des modifizierten Lauchernters

In den vorherigen Artikeln haben wir die Ideen und die Codeimplementierung der ursprünglichen Spot-Version der Hochfrequenzstrategie des Lauchernters analysiert.

Analyse der Lauchernte-Strategie (1) Analyse der Lauchernte-Strategie (2)

Viele Nutzer der Quantifizierung des Währungskreises sind eher besorgt überprint moneyDie Strategie des Chefs,print moneyDie Strategie des Chefs besteht darin, USDT-Kontrakte auf Binance zu handeln. Aus den Beobachtungen und Analysen vieler Anhänger geht hervor, dass diese Hochfrequenzstrategie dem Prinzip eines Laucherntegeräts ähnelt (Cao Shen sagte auch, dass die Prinzipien der Hochfrequenzstrategien relativ ähnlich seien). Doch es gibt durchaus Feinheiten, die dafür sorgen können, dass die Strategie eine stabile Gewinnquote und ein entsprechendes Gewinn- und Verlustverhältnis aufweist.

Der Redakteur, der darauf brannte, seine Fähigkeiten unter Beweis zu stellen, konnte also nicht anders, als einige Änderungen vorzunehmen, obwohl die Wirkung der geänderten Strategie durch die Strategien der Meister zunichte gemacht wurde. Es kann aber auch als Lernen und Einüben von Hochfrequenzstrategien angesehen werden. Interessierte FMZer können diskutieren und gemeinsam lernen.

Modifizierter Lauch-Erntegerät

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

Ideen zur Strategieänderung

Die Strategie besteht darin, den Handel auf dem Binance USDT-Vertragsmarkt zu planen. Binance-Verträge unterstützen Einwegpositionen. Daher wird die Strategie entsprechend den Merkmalen von Einwegpositionen modifiziert und gestaltet (Einwegpositionen eignen sich besser für Strategiemodifikationen), ohne das Schließen von Positionen zu berücksichtigen, sondern nur das Kaufen und Verkaufen. Diese Idee kommt der Spot-Version des Lauch-Erntegeräts näher.

Die Strategie behält im Wesentlichen die ursprünglichen Beurteilungskriterien für den kurzfristigen Preistrenddurchbruch bei, und der kurzfristige Preisdurchbruchsbereich wird durch den Parameter bestimmtburstThresholdPctKontrolle, nach dieser Beurteilungsbedingung ist der kurzfristige Preisbull(Kuh) oderbear(Tragen).

Die Strategie entfernt einige Module aus der Originalversion, beispielsweise das Balance-Modul. Die größte Änderung besteht darin, dass die Order nun so geändert wurde, dass eine Bestellung in das Auftragsbuch eingetragen und auf die Transaktion gewartet wird. Es wird erwartet, dass in einem chaotischen Markt, in dem die langen und kurzen Spiele heftig sind, eine Position zu geringeren Kosten eröffnet wird, dem kurzfristigen Trend folgt, die Position schließt, wenn sich der kurzfristige Trend umkehrt, und weiterhin Positionen mit umgekehrter Reihenfolge eröffnet werden. .

Die Strategie entfernt andere nutzlose Codes, sodass sie sehr kurz und einfach ist. Obwohl die Strategie nicht profitabel ist und sogar Geld verliert, ist es ein Modell, das von FMZern verwendet werden kann, um Hochfrequenzstrategien zu erlernen, das Verhalten von Hochfrequenzstrategien zu beobachten und die Mikrogesetze des Marktes zu beobachten. Algorithmischer Handel und quantitativer Handel erfordern viel Praxis, Erfahrung und Theorie als Grundlage.

Lauf eine Weile

Es zeigt sich, dass es schwieriger ist, Positionen zu eröffnen und zu schließen, wenn der Markt nicht aktiv ist.

Strategieoptimierung

Derzeit konnte noch keine gute Optimierungsrichtung gefunden werden. Interessierte Studierende sind herzlich eingeladen, sich zu Wort zu melden und gemeinsam zu diskutieren.

Strategieadresse: https://www.fmz.com/strategy/260806

Diese Strategie dient ausschließlich Lernzwecken. Bei einem stagnierenden Markt kann es beim tatsächlichen Handel zu Verlusten kommen.