Thảo luận về thiết kế chiến lược tần số cao Máy thu hoạch lợi nhuận biến đổi ma thuật

Thảo luận về thiết kế chiến lược tần số cao Máy thu hoạch lợi nhuận biến đổi ma thuật

Trong các bài viết trước, chúng tôi đã phân tích các ý tưởng và thực hiện mã của phiên bản điểm ban đầu của chiến lược thu hoạch lợi nhuận tần số cao.

Phân tích thu hoạch lợi nhuận (1) Phân tích thu hoạch lợi nhuận (2)

Nhiều người dùng trong vòng tròn tiền điện tử định lượng rất quan tâm đến chiến lược được phát triển bởi một bậc thầy gọi làin tiềnChiến lược củain tiềnTừ quan sát và phân tích của nhiều người theo dõi, có thể thấy rằng chiến lược tần số cao tương tự như nguyên tắc thu hoạch lợi nhuận (thầy Xiaocao cũng nói rằng nguyên tắc của chiến lược tần số cao tương tự như thu hoạch lợi nhuận).

Vì vậy, tôi đã rất phấn khích rằng tôi không thể giúp nhưng muốn thay đổi một cách kỳ diệu chiến lược, ngay cả chiến lược thay đổi một cách kỳ diệu kết quả và hiệu ứng là không có gì trước các chiến lược được phát triển bởi các bậc thầy.

Máy thu hoạch lợi nhuận được sửa đổi một cách kỳ diệu

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

Ý tưởng sửa đổi

Chiến lược này được lên kế hoạch để giao dịch trên thị trường hợp đồng Binance USDT, hỗ trợ các vị trí một chiều. Do đó, chiến lược được sửa đổi và thiết kế theo các đặc điểm của các vị trí một chiều (các vị trí một chiều thuận tiện hơn để sửa đổi chiến lược), và bạn chỉ cần xem xét mua và bán, không cần phải nghĩ đến việc đóng các vị trí. Cách suy nghĩ này cũng gần hơn với phiên bản giao ngay của máy thu lợi nhuận.

Chiến lược về cơ bản giữ nguyên tiêu chí đột phá xu hướng giá ngắn hạn ban đầu, và phạm vi đột phá giá ngắn hạn được kiểm soát bởi tham sốburstThresholdPctTheo tiêu chí để xác định giá ngắn hạn làbullhoặcbear.

Chiến lược này loại bỏ một số mô-đun từ bản gốc, chẳng hạn như mô-đun cân đối. Nó dự kiến sẽ mở các vị trí với chi phí tương đối thấp trong thị trường hỗn loạn với trò chơi ngắn dài khốc liệt, theo xu hướng ngắn hạn và đóng các vị trí khi xu hướng ngắn hạn đảo ngược, và sau đó tiếp tục chờ lệnh và mở các vị trí ngược lại.

Chiến lược loại bỏ các mã vô dụng khác, vì vậy nó rất ngắn và đơn giản. Mặc dù chiến lược là một chiến lược không có lợi nhuận, ngay cả với tổn thất, nhưng nó là một mô hình rất dễ dàng và hữu ích cho một FMZer để học các chiến lược tần số cao, quan sát các hành động của các chiến lược tần số cao, quan sát các quy tắc vi mô của thị trường, v.v.

Chạy trong Bot

Có thể thấy rằng việc mở và đóng các vị trí khó khăn hơn khi tình hình thị trường không hoạt động.

Tối ưu hóa chiến lược

Hiện tại, không có hướng tối ưu hóa tốt nào được tìm thấy. Học sinh, những người quan tâm, có thể nói lên tích cực và thảo luận với nhau.

Địa chỉ chiến lược:https://www.fmz.com/strategy/260806

Chiến lược chỉ dành cho nghiên cứu; khi thị trường phẳng, chạy nó trong bot có thể gây tổn thất.