Transplante OKCoin para cosechadora de colza

El autor:No hay nada, Fecha: 2017-01-30 19:38:25
Las etiquetas:De alta frecuencia

Los trasplantes son:https://github.com/richox/okcoin-leeks-reaper

El autor original dijo que no funcionaría después de cobrar la tarifa, solo hice el trasplante, no hubo pruebas en vivo, estaba interesado en aprender. Los inventores cuantifican la repetición a nivel de Tick con soporte para la reproducción de Depth y Trades, y pueden realizar una repetición directa de la lógica de la estrategia de aprendizaje.

La siguiente es la descripción original:

La cosechadora de colza OKCoin

Este es un programa de robots de comercio de alta frecuencia en la plataforma de comercio de Bitcoin OKCoin, que se basó en la estrategia de junio de 2016 y, a mediados de enero de 2017, la estrategia bronceó con éxito los 6.000 dólares que se invirtieron inicialmente a 250.000.

image

Este programa de robots está basado en dos estrategias principales:

  1. Estrategia de tendencia: cuando el precio tiene una fluctuación de tendencia, se realiza un seguimiento oportuno de la orden, es decir, se diceLa búsqueda y el asesinato
  2. Estrategia de equilibrio: cuando una posición se desvía un 50%, se emite un prospecto para que la posición regrese gradualmente un 50%, evitando que la reversión del final de la tendencia provoque un retroceso, es decir,Los beneficios de las bolsas, no comer cola de pescado

Este procedimiento requiere equilibrar las posiciones, es decir, (capital + financiación = dinero), para que las posiciones en el 50% de los activos netos no fluctúen con los precios, pero también garantizan cuando se producen fluctuaciones tendenciales.Los que caen también caen

Gracias a los siguientes dos proyectos:

Gracias a OKCoin:

Las operaciones de las entidades de crédito se ejecutan de conformidad con el artículo 4 del Reglamento (UE) n.o 575/2013.


/*backtest
start: 2019-09-05 00:00:00
end: 2019-09-05 22:00:00
period: 1h
exchanges: [{"eid":"Binance","currency":"BTC_USDT","fee":[0,0]}]
mode: 1
*/

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.p = 0.5
    self.account = null
    self.preCalc = 0
    self.preNet = 0

    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.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.35 +
            (orderBook.Bids[1].Price + orderBook.Asks[1].Price) * 0.1 +
            (orderBook.Bids[2].Price + orderBook.Asks[2].Price) * 0.05))
    }
    self.balanceAccount = function() {
        var account = exchange.GetAccount()
        if (!account) {
            return
        }
        self.account = account
        var now = new Date().getTime()
        if (self.orderBook.Bids.length > 0 && now - self.preCalc > (CalcNetInterval * 1000)) {
            self.preCalc = now
            var net = _N(account.Balance + account.FrozenBalance + self.orderBook.Bids[0].Price * (account.Stocks + account.FrozenStocks))
            if (net != self.preNet) {
                self.preNet = net
                LogProfit(net)
            }
        }
        self.btc = account.Stocks
        self.cny = account.Balance
        self.p = self.btc * self.prices[self.prices.length-1] / (self.btc * self.prices[self.prices.length-1] + self.cny)
        var balanced = false
        
        if (self.p < 0.48) {
            Log("开始平衡", self.p)
            self.cny -= 300
            if (self.orderBook.Bids.length >0) {
                exchange.Buy(self.orderBook.Bids[0].Price + 0.00, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.01, 0.01)
                exchange.Buy(self.orderBook.Bids[0].Price + 0.02, 0.01)
            }
        } else if (self.p > 0.52) {
            Log("开始平衡", self.p)
            self.btc -= 0.03
            if (self.orderBook.Asks.length >0) {
                exchange.Sell(self.orderBook.Asks[0].Price - 0.00, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.01, 0.01)
                exchange.Sell(self.orderBook.Asks[0].Price - 0.02, 0.01)
            }
        }
        Sleep(BalanceTimeout)
        var orders = exchange.GetOrders()
        if (orders) {
            for (var i = 0; i < orders.length; i++) {
                if (orders[i].Id != self.tradeOrderId) {
                    exchange.CancelOrder(orders[i].Id)
                }
            }
        }
    }

    self.poll = function() {
        self.numTick++
        self.updateTrades()
        self.updateOrderBook()
        self.balanceAccount()
        
        var burstPrice = self.prices[self.prices.length-1] * BurstThresholdPct
        var bull = false
        var bear = false
        var tradeAmount = 0
        if (self.account) {
            LogStatus(self.account, 'Tick:', self.numTick, ', 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
            tradeAmount = self.cny / self.bidPrice * 0.99
        } 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
            tradeAmount = self.btc
        }
        if (self.vol < BurstThresholdVol) {
            tradeAmount *= self.vol / BurstThresholdVol
        }
        
        if (self.numTick < 5) {
            tradeAmount *= 0.8
        }
        
        if (self.numTick < 10) {
            tradeAmount *= 0.8
        }
        
        if ((!bull && !bear) || tradeAmount < MinStock) {
            return
        }
        var tradePrice = bull ? self.bidPrice : self.askPrice
        while (tradeAmount >= MinStock) {
            var orderId = bull ? exchange.Buy(self.bidPrice, tradeAmount) : exchange.Sell(self.askPrice, tradeAmount)
            Sleep(200)
            if (orderId) {
                self.tradeOrderId = orderId
                var order = null
                while (true) {
                    order = exchange.GetOrder(orderId)
                    if (order) {
                        if (order.Status == ORDER_STATE_PENDING) {
                            exchange.CancelOrder(orderId)
                            Sleep(200)
                        } else {
                            break
                        }
                    }
                }
                self.tradeOrderId = 0
                tradeAmount -= order.DealAmount
                tradeAmount *= 0.9
                if (order.Status == ORDER_STATE_CANCELED) {
                    self.updateOrderBook()
                    while (bull && self.bidPrice - tradePrice > 0.1) {
                        tradeAmount *= 0.99
                        tradePrice += 0.1
                    }
                    while (bear && self.askPrice - tradePrice < -0.1) {
                        tradeAmount *= 0.99
                        tradePrice -= 0.1
                    }
                }
            }
        }
        self.numTick = 0
    }
    return self
}

function main() {
    var reaper = LeeksReaper()
    while (true) {
        reaper.poll()
        Sleep(TickInterval)
    }
}

Relacionados

Más.

El rey del hip-hopLa estrategia ha fracasado, y los beneficios provienen de ingresos de alta frecuencia de baja diferenciación con cero tarifas de tramitación.

- ¿ Qué pasa? self.vol到底是个啥?是一个ticker期间内所有交易量的总和吗?

el díaTrader2018para (var i = 0; i < 15; i++) { self.prices[i] = trades[trades.length - 1].Precio }; ¿No es un poco problemático que cada elemento de la matriz de precios sea el precio de transacción más reciente?

¿Qué es eso?Tengo varias bolsas de intercambio que operan muy bien sin gastos de tramitación. ¿Puedes probar esta estrategia?

¿Qué es eso?Eso es genial, pero no sirve, ¿puede funcionar ahora?

el fuego del cieloNota de venta: 2000 ejemplares, no oficiales, con intención de enlace

¡Rajá!¿Alguien que lo haya probado ha salido a discutir los beneficios?

Valencio¿Cuándo llegará el comentario?

el pueblo de Wuqianming¿Cómo se ejecuta un intercambio sin botvs, libre de transacciones, y cómo se escribe un API de intercambio?

J.¡Gracias por compartir esta buena estrategia! exchange.CancelOrder ((orders[i].Id) El código de cancelación aquí tiene un poco de problema, el proceso de cancelación y cancelación continua durante la prueba. Si vemos el código de la versión original, debería haber sido retirado después de 10 segundos. El resto es prácticamente normal, lo modifico y lo pongo en una bolsa libre de gastos de mantenimiento, me siento bien.

El estudio km 66行prices需加.length

Arroz de nieve¿Qué lengua es?

No hay nada 平衡那里下单忘加上Price属性了。。已更正,有发现bug请及时提交.

El aguaParece que hay estrategias para ganar dinero, o no vender, y quedarse con su dinero.

1213761768No lo dejan salir.

No hay duda.No, el bidprice tiene que ser menor que el askprice, uno es el precio de compra, uno es el precio de venta.

¿Qué es eso?Por favor, cuando se calcula el precio de la oferta y el precio de la demanda, el pedido se hace como si no se determinara si el precio de la oferta es mayor que el precio de la demanda, así que si la compra y la venta están muy cerca, se calcula que es muy probable que sea una compra alta y una venta baja. ¿Habrá este problema?

Me encanta la peluca.Yo escribí un comentario, y todos necesitan poder añadir Hoo_tongxue a mi WeChat, y lo mejor de todo es que es gratis.

Me encanta la peluca.La verdadera piel es lo suficientemente gruesa como para vestir.

Las pequeñas bolas de carbón¿Qué bolsas?

No hay nadaEsto debería initializarse al precio más reciente, con el operador de cambio detrás.

La reestructuración es un milagro.En la actualidad, la guerra de los robots está en marcha.

sucoSí, sí, esta col rizada es mejor.

el fuego del cieloQue el vendedor venda y que el comprador compre, y no te dispute.

Las novias también.Todos han abierto el código fuente, ¿por qué no comentas, vender 2000?

¿Qué quieres decir? 请问zaif.jp现在还是免手续费吗?怎么通过认证呢

- ¿Qué quieres decir?Veamos el ID.

J. 在Zaif.jp上测试,买一卖一间经常就没有空间,用这个策略有什么问题吗?

J.¿Es verdad? ¡Salgan y denles una lección!

- ¿Qué quieres decir?El autor original se sorprendió

J.Bueno, hay algunas preguntas, por favor, y otro post: https://www.botvs.com/bbs-topic/677

No hay nadaSi tienes alguna lección que compartir o alguna duda sobre esta estrategia, póngalo en el foro, ¡gracias por tu apoyo!

No hay nadaGracias por la sugerencia, he añadido un parámetro, el tiempo de espera de la orden de equilibrio, si se quiere procesar simultáneamente, se puede registrar la ID de cada orden con el tiempo de pedido, y luego cancelar selectivamente, lo que reduce la demora, pero lógicamente, debe ser el equilibrio de nuevo primero, puesto que no todos los intercambios de apoyo a la hora de obtener la orden de la propiedad, por lo que la plataforma no añade esta propiedad en la orden, necesita sus propias estadísticas.

- ¿Qué quieres decir?Me parece una estrategia extraña, me gusta.

No hay nadaEso no lo he probado, lo que necesito es que lo investiguen ustedes mismos.

Orión 1708Por favor, ¿el cambio en el valor predeterminado de los parámetros de la política tiene un gran impacto en la política?

No hay nadaHa ha, gracias, ya está.

No hay nadaEl código JavaScript

No hay nadaFrecuencia de las transacciones

Un sueño pequeño.El autor original también se hizo público en los días en que cobró la cuota.

- ¿Qué quieres decir?¿Por qué la estrategia de tendencia tiene miedo de los costos de impacto?