Discussion sur la conception d'une stratégie à haute fréquence du point de vue de la cueilleuse de poireaux modifiée

Dans les articles précédents, nous avons analysé les idées et la mise en œuvre du code de la version spot originale de la stratégie haute fréquence de la récolteuse de poireaux.

Analyse de la stratégie de récolte des poireaux (1)
Analyse de la stratégie de récolte des poireaux (2)

De nombreux utilisateurs du cercle de pièces sont plus préoccupés parprint moneyLa stratégie du patron,print moneyLa stratégie du patron est de négocier des contrats USDT sur Binance. D'après les observations et les analyses de nombreux adeptes, on peut constater que cette stratégie à haute fréquence est similaire au principe d'une cueilleuse de poireaux (Cao Shen a également déclaré que les principes des stratégies à haute fréquence sont relativement proches). Mais il existe certainement des subtilités qui peuvent garantir que la stratégie a un taux de gain stable et un ratio de profits et de pertes approprié.

Ainsi, l'éditeur qui avait hâte de montrer ses compétences n'a pas pu s'empêcher d'apporter quelques modifications, même si l'effet de la stratégie modifiée a été réduit en cendres par les stratégies des maîtres. Mais cela peut aussi être considéré comme un apprentissage et une pratique de stratégies à haute fréquence. Les FMZers intéressés peuvent en discuter et apprendre ensemble.

Récolteuse de poireaux modifiée

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

Idées de modification de stratégie

La stratégie consiste à planifier l'utilisation du trading sur le marché des contrats Binance USDT. Les contrats Binance prennent en charge les positions à sens unique. Par conséquent, la stratégie est modifiée et conçue en fonction des caractéristiques des positions à sens unique (les positions à sens unique sont plus pratiques pour la modification de la stratégie), sans tenir compte des positions de clôture, mais uniquement de l'achat et de la vente. Cette idée se rapproche davantage de la version spot de la cueilleuse de poireaux.

La stratégie conserve fondamentalement les critères de jugement de rupture de tendance de prix à court terme d'origine, et la plage de rupture de prix à court terme est déterminée par le paramètreburstThresholdPctContrôle, selon cette condition de jugement, le prix à court terme estbull(vache), oubear(Ours).

La stratégie supprime certains modules de la version originale, comme le module d'équilibrage. Le changement le plus important est que l'ordre a été modifié pour passer une commande dans le carnet de commandes et attendre que la transaction soit terminée.
Il est prévu d'ouvrir une position à moindre coût dans un marché chaotique où les jeux longs et courts sont féroces, de suivre la tendance à court terme, de fermer la position lorsque la tendance à court terme s'inverse et de continuer à ouvrir des positions avec des ordres inversés. .

La stratégie supprime d’autres codes inutiles, elle est donc très courte et simple. Bien que la stratégie ne soit pas rentable et perde même de l'argent, c'est un modèle qui peut être utilisé par les FMZers pour apprendre des stratégies à haute fréquence, observer le comportement des stratégies à haute fréquence et observer les micro-lois du marché. Le trading algorithmique et le trading quantitatif nécessitent beaucoup de pratique, d'expérience et de théorie comme base.

Courir un moment

On constate qu’il est plus difficile d’ouvrir et de fermer des positions lorsque le marché n’est pas actif.

Optimisation de la stratégie

À l’heure actuelle, aucune bonne direction d’optimisation n’a été trouvée.
Les étudiants intéressés sont invités à prendre la parole et à discuter ensemble.

Adresse de la stratégie : https://www.fmz.com/strategy/260806

Cette stratégie est uniquement destinée à des fins d'apprentissage et les transactions réelles peuvent entraîner des pertes si le marché est stable.