Desenho de estratégias de alta frequência da máquina de colheita de laranja da Marvel

Desenho de estratégias de alta frequência da máquina de colheita de laranja da Marvel

Nos artigos anteriores, analisamos as ideias para a estratégia de alta freqüência da máquina de colheita de louro disponível na versão original e a implementação do código.

Análise estratégica da máquina de colheita de louro (1) Análise estratégica da máquina de colheita de laranja (2)

Muitos usuários estão mais preocupados com a quantificação do círculo.imprimir dinheiroA estratégia da tigela,imprimir dinheiroA estratégia de Daejeon é a negociação de contratos em Binance USDT. De acordo com observações e análises de muitos observadores, a estratégia de alta frequência é semelhante aos princípios de uma colhedora de espinafre (Grassinha também disse que os princípios da estratégia de alta frequência são mais próximos). Mas certamente há sutilezas para que a estratégia tenha uma taxa de vitória estável e uma relação de ganho e perda adequada.

Por isso, os alunos de técnica também não conseguiram resistir a mudar um pouco, embora os efeitos da estratégia alterada fossem esmagados em escória pela estratégia dos grandes deuses. Mas também é uma prática de aprendizado de estratégias de alta frequência, os colegas de FM Zer interessados devem se reunir para explorar e aprender.

A máquina de colheita de repolho transformada em magia

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

Mudança de estratégia

A estratégia é planejada para ser usada no mercado de negociação de contratos USDT em Binance, onde os contratos Binance suportam a posse unidirecional. Assim, a estratégia é modificada de acordo com as características da posse unidirecional ("posse unidirecional é mais conveniente para a mudança da estratégia"), não considerando o equilíbrio, apenas considerando a compra e venda.

A estratégia basicamente mantém o padrão de determinação da brecha de tendência de preços de curto prazo da versão original, e a amplitude da brecha de preços de curto prazo é definida por parâmetros.burstThresholdPctO preço de curto prazo é o preço de curto prazo, o preço de curto prazo é o preço de curto prazo.bull(vacas) oubear(Ourse)

A política remove alguns módulos do original, como o módulo de equilíbrio. Uma grande mudança é alterar a ordem para colocar a ordem na folha de pedidos, aguardando transação. A expectativa é de abrir um negócio com um custo mais baixo em um cenário de grande confusão, seguir uma tendência de curto prazo, e continuar a abrir um negócio com um pendente de retorno quando a tendência de curto prazo se inverter.

A estratégia é muito curta e simples. Embora a estratégia seja uma estratégia que não ganha dinheiro ou até mesmo perde dinheiro, como FMZer, aprender estratégias de alta frequência, observar o comportamento das estratégias de alta frequência, observar as leis microscópicas do mercado, etc. é um modelo que pode ser desenvolvido.

A sério, por favor.

Como se pode ver, é mais difícil abrir uma posição quando o mercado não está ativo.

Optimização estratégica

No momento, não há uma boa direção para a otimização. Os alunos interessados em participar podem participar e discutir.

A estratégia é endereçada:https://www.fmz.com/strategy/260806

Esta estratégia é apenas para aprender, e o mercado está em um plano de negócios que pode causar prejuízos.