Desarrollo de estrategias de alta frecuencia desde la cosechadora de colza de Magma

Desarrollo de estrategias de alta frecuencia desde la cosechadora de colza de Magma

En los artículos anteriores hemos analizado la idea de la estrategia de alta frecuencia y la implementación del código de la recolectora de espinacas de la versión original.

Estrategias de disección de cosechadoras de colza (1) Las estrategias de disección de las cosechadoras de colza (2)

Muchos usuarios están más preocupados por la cuantificación de la moneda.Imprimir dineroLa estrategia de la tortugaImprimir dineroLa estrategia de Daejeon es la negociación de contratos de Bitcoin USDT. De acuerdo con la observación y el análisis de numerosos observadores, la estrategia de alta frecuencia es similar a la de una cosechadora de espinacas (Grassin también dijo que la estrategia de alta frecuencia es más cercana). Sin embargo, hay ciertos trucos para lograr que la estrategia tenga una tasa de ganancia estable y una relación de ganancias y pérdidas adecuada.

Por lo tanto, los maestros no pueden resistirse a cambiar la táctica, aunque el efecto de la táctica cambiada por la magia se ha reducido a escoria por la táctica de los dioses. Pero también es una práctica de aprendizaje de la táctica de alta frecuencia, los compañeros de FM Zer interesados deben venir a explorar y aprender.

La cosechadora de colza con el hechizo

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

El cambio de estrategia

La estrategia es planear el uso de operaciones en el mercado de contratos USDT de Binance, los contratos de Binance apoyan la tenencia unidireccional. Por lo tanto, la estrategia se modifica según las características de la tenencia unidireccional (la tenencia unidireccional es más conveniente para la modificación de la estrategia), no se considera el equilibrio, solo se considera la compra y venta.

La estrategia se mantiene básicamente en la versión original para determinar los parámetros de ruptura de tendencias de precios a corto plazo, y el alcance de la ruptura de precios a corto plazo se basa en parámetros.burstThresholdPctEl precio corto es el precio más bajo de los precios a corto plazo, y el precio corto es el precio más bajo del precio a corto plazo.bull(vacas), obear(Oso) También.

La política elimina algunos módulos de la versión original, como el módulo de equilibrio. Un cambio más grande es cambiar el orden de entrega para colocar el pedido en el bolsillo de la orden y esperar la transacción. Se espera que se abra una posición con un costo más bajo en un panorama de caos intenso, que siga la tendencia corta y se estabilice cuando la tendencia corta se invierte, y continúe poniendo una posición en suspensión al revés.

La estrategia es muy corta y sencilla, ya que elimina el resto de código inútil. Aunque la estrategia no es una estrategia para ganar o incluso perder dinero, como FMZer, aprender estrategias de alta frecuencia, observar el comportamiento de las estrategias de alta frecuencia, observar las leyes microscópicas del mercado, etc. es un modelo accesible. La negociación programada, la negociación cuantitativa requieren una gran cantidad de práctica, experiencia y teoría como base.

¿Qué es lo que está pasando?

Como se puede ver, es más difícil abrir una posición de liquidación cuando el mercado no está activo.

Optimización estratégica

En la actualidad, no se ha encontrado una buena dirección de optimización. Los estudiantes interesados pueden participar y hablar juntos.

La dirección de la estrategia:https://www.fmz.com/strategy/260806

Esta estrategia es sólo para aprender, el mercado está en un plano plano y puede perder.