리크스리퍼의 마법적 변화에서 고주파 전략 디자인을 탐구하십시오.

이전 기사에서는 원래 스팟 버전인 리크 리퍼의 고주파 전략의 아이디어와 코드 구현을 분석했습니다.

리크스리퍼 전략 분석 (1)https://www.fmz.com/bbs-topic/9725) 리크스리퍼 전략 분석 (2)https://www.fmz.com/bbs-topic/9733）

디지털 통화의 많은 사용자는 프린트 머니 리더의 전략에 더 많은 관심을 기울인다. 프린트 머니 리더의 전략은 바이낸스 USDT 계약에서 거래된다. 많은 추종자들의 관찰과 분석에서 이러한 고주파 전략이 리크스 리퍼의 원칙과 유사하다는 것을 알 수 있다 (지도자 샤오카오도 고주파 전략의 원칙이 유사하다고 말했다). 그러나 안정적인 승률과 적절한 이익과 손실 비율을 달성하기 위해서는 미묘한 무언가가 있어야합니다.

따라서, 나는 마법의 변화를 만들지 않을 수 없었다. 비록 마법의 변화의 전략 효과는 지도자의 전략보다 훨씬 나빴다. 그것은 또한 고주파 전략에 대한 학습 연습이다. FMZer에 관심이있는 사람들은 함께 논의하고 배우게 될 것입니다.

마법의 변화 후 리크리퍼

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

전략 변경의 아이디어

전략은 일방적 포지션을 지원하는 바이낸스 USDT 계약 시장에서 거래를 계획하는 것입니다. 따라서 전략은 일방적 포지션의 특성에 따라 수정됩니다 (일방적 포지션은 전략을 수정하는 것이 더 편리합니다), 우리는 포지션을 닫는 것을 고려하지 않습니다. 우리는 단지 판매와 구매를 고려합니다. 아이디어는 리크 리퍼의 스팟 버전에 더 가깝습니다.

이 전략은 기본적으로 단기 가격 트렌드 돌파의 원래 기준을 유지합니다. 이는 매개 변수에 의해 제어됩니다.burstThresholdPCT, 즉 단기 가격의bull또는bear.

전략은 균형 모듈과 같은 원래 모듈의 일부를 제거합니다. 더 큰 변화는 거래서를 기다리는 주문자입니다. 그것은 혼란스러운 긴 / 짧은 게임에서 낮은 비용으로 위치를 열고, 단기 트렌드를 따라, 단기 트렌드가 반전되면 위치를 닫고, 반전 미뤄있는 명령으로 위치를 계속 여는 것으로 예상됩니다.

전략은 짧고 간단합니다. 다른 쓸모없는 코드를 제거했기 때문입니다. 전략은 돈을 벌지 않거나 돈을 잃지 않는 전략이지만, FMZer로서 고주파 전략을 배우고, 고주파 전략의 행동을 관찰하고, 시장의 미세 법칙을 관찰하는 것은 사용할 수있는 모델입니다. 프로그램 거래와 정량 거래는 많은 연습, 경험, 이론이 기본이 필요합니다.

전략 최적화

현재 최적화의 좋은 방향은 발견되지 않았습니다. 관심 있는 사람 은 당신 의 의견 을 남기고 함께 토론 할 수 있습니다.

전략:https://www.fmz.com/strategy/260806

이 전략은 학습을 위한 것입니다. 실제 로봇은 시장이 낙관적이지 않을 때 손실을 입을 수 있습니다.