Explorez la conception de la stratégie à haute fréquence du changement magique de LeeksReaper

Dans des articles précédents, nous avons analysé l'idée et la mise en œuvre du code de la stratégie haute fréquence de la version spot originale LeeksReaper.

L'analyse de la stratégie de LeeksReaperhttps://www.fmz.com/bbs-topic/9725) L'analyse de la stratégie de LeeksReaperhttps://www.fmz.com/bbs-topic/9733）

Beaucoup d'utilisateurs de la monnaie numérique accordent plus d'attention à la stratégie du leader de l'argent imprimé.La stratégie du leader de l'argent imprimé est négociée dans le contrat Binance USDT.Il peut être vu par l'observation et l'analyse de nombreux abonnés que cette stratégie à haute fréquence est similaire au principe de LeeksReaper (le leader Xiaocao a également déclaré que le principe des stratégies à haute fréquence est similaire).Mais il doit y avoir quelque chose de subtil pour atteindre un taux de gain stable et un ratio de profit et de perte approprié.

Par conséquent, je ne pouvais m'empêcher de faire le changement magique. Bien que l'effet de la stratégie du changement magique était beaucoup pire que les stratégies des dirigeants. C'est aussi une pratique d'apprentissage pour les stratégies à haute fréquence.

LeeksReaper après le changement magique.

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

L'idée de modifier la stratégie

La stratégie consiste à planifier le commerce sur le marché des contrats Binance USDT, qui prend en charge les positions unidirectionnelles. Par conséquent, la stratégie est modifiée en fonction des caractéristiques de la position unidirectionnelle (la position unidirectionnelle est plus pratique pour modifier la stratégie), nous n'envisageons pas de fermer la position, nous considérons seulement la vente et l'achat. L'idée est plus proche de la version au comptant du LeeksReaper.

La stratégie conserve essentiellement le critère d'origine de l'évolution de la tendance des prix à court terme, qui est contrôlée par le paramètreburstThresholdPCT, selon laquelle il est possible d'évaluer si le prix à court terme estbulloubear.

La stratégie élimine certains des modules d'origine, tels que le module de solde. Il est prévu d'ouvrir une position à un coût inférieur dans un jeu chaotique long/short, de suivre la tendance à court terme et de fermer la position lorsque la tendance à court terme s'inverse et de continuer à ouvrir la position avec un ordre en attente inverse.

La stratégie est courte et simple parce qu'elle a supprimé d'autres codes inutiles. Bien que la stratégie soit une stratégie qui ne gagne pas d'argent, ni même de perdre de l'argent, mais en tant que FMZer qui apprennent la stratégie à haute fréquence, l'observation du comportement de la stratégie à haute fréquence, l'observation des micro-lois du marché est un modèle qui peut être utilisé. Le trading de programme et le trading quantitatif ont besoin de beaucoup de pratique, d'expérience, de théorie comme base.

Optimisation de la stratégie

À l'heure actuelle, aucune bonne direction d'optimisation n'a été trouvée. Quelqu'un d'intéressé peut laisser vos commentaires et discuter avec vous.

Stratégie de:https://www.fmz.com/strategy/260806

Cette stratégie est uniquement pour l'apprentissage, le vrai bot peut avoir des pertes lorsque le marché n'est pas très optimiste.