Des techniques de conception de haute fréquence à partir d'un moissonneur de légumes à la magie

Des techniques de conception de haute fréquence à partir d'un moissonneur de légumes à la magie

Dans les articles précédents, nous avons analysé l'idée de la stratégie de haute fréquence et la mise en œuvre du code de la première version de la machine à cueillir les légumineuses.

Découvrez les stratégies d'analyse de la machine à cueillir les légumineuses (1) Une technique de dissection de la machine à cueillir les légumineuses (2)

Beaucoup d'utilisateurs s'intéressent plus à la quantification de l'anneau.imprimer de l'argentLa stratégie de la tortueimprimer de l'argentLa stratégie de Daejeon consiste à négocier des contrats en binance USDT. D'après l'observation et l'analyse de nombreux observateurs, la stratégie de haute fréquence est similaire à celle d'une moissonneuse à légumes (Grassin a également mentionné que la stratégie de haute fréquence est plus proche).

Le petit technicien n'a donc pas pu s'empêcher de changer de tactique, bien que l'effet de la tactique modifiée soit réduit à néant par la tactique des grands dieux. Mais c'est aussi une pratique d'apprentissage de la tactique de haute fréquence.

Le moissonneur de légumineuses enchanté

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

Les stratégies changent

La stratégie prévoit d'utiliser les transactions sur le marché des contrats USDT en binaire, les contrats binaires supportent la tenue unidirectionnelle. Ainsi, la stratégie est modifiée en fonction des caractéristiques de la tenue unidirectionnelle (la tenue unidirectionnelle est plus pratique pour modifier la stratégie), ne prend pas en compte l'équilibre, mais seulement l'achat et la vente.

La stratégie a essentiellement conservé les critères de détermination de la tendance des prix à court terme, la largeur des prix à court terme est déterminée par des paramètres.burstThresholdPctLe prix à court terme est calculé en fonction de ce critère.bull(Bœuf) oubear(Ours)

La stratégie supprime certains modules de l'original, comme le module de mise en balance. Une grande modification est de changer la sous-commande pour la placer dans la feuille de commande en attendant la transaction. On s'attend à ce que les positions soient ouvertes à un coût inférieur dans un environnement chaotique, à suivre les tendances à court terme et à se calmer lorsque les tendances à court terme s'inverseront.

La stratégie est donc très courte et simple. Bien que la stratégie soit une stratégie qui ne rapporte pas de profits, voire de pertes, l'apprentissage de la stratégie haute fréquence, l'observation du comportement de la stratégie haute fréquence, l'observation des lois microscopiques du marché, etc. est un modèle à suivre.

Un peu de course.

Comme vous pouvez le voir, il est plus difficile d'ouvrir une position lorsque le marché n'est pas actif.

Optimisation de la stratégie

Pour l'instant, aucune bonne optimisation n'a été trouvée. Les élèves intéressés sont invités à s'exprimer et à discuter.

L'adresse de la stratégie:https://www.fmz.com/strategy/260806

Cette stratégie est uniquement destinée à l'apprentissage, car une situation normale peut entraîner des pertes.