Discusión sobre el diseño de estrategias de alta frecuencia desde la perspectiva de la cosechadora de puerros modificada

En los artículos anteriores, analizamos las ideas y la implementación del código de la versión spot original de la estrategia de alta frecuencia de la cosechadora de puerros.

Análisis de la estrategia de la cosechadora de puerros (1)
Análisis de la estrategia de la cosechadora de puerros (2)

Muchos usuarios del círculo de monedas están más preocupados porprint moneyLa estrategia del jefe,print moneyLa estrategia del jefe es negociar contratos USDT en Binance. De las observaciones y análisis de muchos seguidores, se puede ver que esta estrategia de alta frecuencia es similar al principio de una cosechadora de puerros (Cao Shen también dijo que los principios de las estrategias de alta frecuencia son relativamente cercanos). Pero definitivamente hay sutilezas que pueden garantizar que la estrategia tenga una tasa de ganancias estable y una relación de ganancias y pérdidas adecuada.

Así que el editor, ansioso por mostrar sus habilidades, no pudo evitar hacer algunas modificaciones, aunque el efecto de la estrategia modificada fue aplastado por las estrategias de los maestros. Pero también puede considerarse como un aprendizaje y una práctica de estrategias de alta frecuencia. Los FMZers interesados pueden debatir y aprender juntos.

Cosechadora de puerros modificada


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

Ideas de modificación de la estrategia

La estrategia es planificar el uso de operaciones en el mercado de contratos USDT de Binance. Los contratos de Binance admiten posiciones unidireccionales. Por lo tanto, la estrategia se modifica y diseña de acuerdo a las características de las posiciones unidireccionales (las posiciones unidireccionales son más convenientes para la modificación de la estrategia), sin considerar el cierre de posiciones, solo considerando la compra y la venta. Esta idea se acerca más a la versión local de la cosechadora de puerros.

La estrategia básicamente conserva los criterios de juicio de ruptura de la tendencia de precios a corto plazo originales, y el rango de ruptura de precios a corto plazo está determinado por el parámetroburstThresholdPctControl, según esta condición de juicio, el precio de corto plazo esbull(vaca), obear(Oso).

La estrategia elimina algunos módulos de la versión original, como el módulo de equilibrio. El cambio más grande es que el orden ha cambiado a colocar un pedido en el libro de pedidos y esperar la transacción.
Se espera abrir una posición a un costo menor en un mercado caótico donde los juegos largos y cortos son feroces, seguir la tendencia a corto plazo, cerrar la posición cuando la tendencia a corto plazo se revierta y continuar abriendo posiciones con órdenes inversas. .

La estrategia elimina otros códigos inútiles, por lo que es muy corta y sencilla. Aunque la estrategia no es rentable e incluso pierde dinero, es un modelo que los FMZers pueden utilizar para aprender estrategias de alta frecuencia, observar el comportamiento de las estrategias de alta frecuencia y observar las microleyes del mercado. El comercio algorítmico y el comercio cuantitativo requieren mucha práctica, experiencia y teoría como base.