Hochfrequenz-Strategie-Design von der Magma-Sauerbrennerei erforscht

Hochfrequenz-Strategie-Design von der Magma-Sauerbrennerei erforscht

In den vergangenen Artikeln haben wir die Ideen für die Hochfrequenzstrategie und die Codeimplementierung der originalen, stand-alone Ausgabe des Celery Harvesters analysiert.

Die Strategie der Ernte von Salami-Reinern ((1) Die Strategie der Ernte von Leberhackern ((2)

Viele Benutzer sind mehr interessiert an der Quantisierung von Münzkreisen.Geld druckenDie Strategie der Maus,Geld druckenDie Strategie der Dawei ist der Handel mit USDT-Kontrakten. Aus Beobachtungen und Analysen zahlreicher Beobachter geht hervor, dass die Hochfrequenzstrategie ähnlich wie ein Kohlensäure-Harvester funktioniert (Strauschen hat auch gesagt, dass die Hochfrequenzstrategie ähnlich ist).

So konnte sich auch der kleine Techniker nicht wehren, einen Zauberspiel zu machen, obwohl die veränderten Strategien von den großen Göttern zu Schrott gepresst wurden. Aber es ist auch eine Lernpraxis für die Hochfrequenzstrategie.

Ein verrückter Salami-Reinerer

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

Strategische Veränderungen

Die Strategie ist die Planung der Verwendung in der Binance-USDT-Kontraktmarkthandel, Binance-Kontrakte unterstützen einseitige Halten. So ist die Strategie entsprechend der Eigenschaften der einseitigen Halten Design geändert ("einseitige Halten ist bequemer Strategie zu ändern), nicht zu berücksichtigen Bilanz, nur zu kaufen und zu verkaufen.

Die Strategie behält im Wesentlichen die ursprünglichen Kriterien für die Bestimmung von kurzfristigen Preistrends bei, wobei die Breite der kurzfristigen Preise durch Parameter bestimmt wird.burstThresholdPctDer Preis wird von einem bestimmten Wert bestimmt, der von einem bestimmten Wert bestimmt wird.bull(Kühe) oderbear(Bär)

Die Strategie entfernt einige Module aus der Originalversion, wie z.B. das Balance-Modul. Eine größere Änderung ist die Änderung der Unterbestellung, um die Bestellungen in der Bestellkarte zu hängen und auf die Transaktion zu warten. Es wird erwartet, dass man in einem chaotischen Umfeld mit niedrigeren Kosten tritt, dem Kurzzeittrend folgt und bei einer Umkehr des Kurzzeittrends ausfällt, um weiter aufzuhängen.

Die Strategie ist sehr kurz und einfach, weil sie den anderen nicht verwendeten Code entfernt. Obwohl die Strategie eine Strategie ist, die keinen Gewinn oder sogar keinen Verlust mit sich bringt, ist es als FMZer ein Modell, das man annehmen kann, wenn man sich die Hochfrequenzstrategien anschaut, die Verhaltensweisen der Hochfrequenzstrategien beobachtet, die mikroskopischen Marktgesetze beobachtet und so weiter.

Wirklich laufen.

Wie man sieht, ist es schwieriger, eine Position zu eröffnen, wenn die Märkte nicht aktiv sind.

Optimierung der Strategie

Derzeit gibt es noch keine gute Optimierungsrichtung. Interessierte Schülerinnen und Schüler können sich gerne äußern und gemeinsam diskutieren.

Die Strategie ist unter:https://www.fmz.com/strategy/260806

Diese Strategie dient nur dem Lernen und kann zu Verlusten führen.