লিক্স রিপার এর ম্যাজিক পরিবর্তন থেকে উচ্চ ফ্রিকোয়েন্সি কৌশল নকশা অন্বেষণ করুন

পূর্ববর্তী নিবন্ধে, আমরা মূল স্পট সংস্করণ লিক্স রিপার এর উচ্চ-ফ্রিকোয়েন্সি কৌশলটির ধারণা এবং কোড বাস্তবায়ন বিশ্লেষণ করেছি।

লেকস রিপার কৌশল বিশ্লেষণ (১) (১)https://www.fmz.com/bbs-topic/9725) লিক্স রিপার কৌশল বিশ্লেষণ (২) (২)https://www.fmz.com/bbs-topic/9733）

ডিজিটাল মুদ্রার অনেক ব্যবহারকারী প্রিন্টমনি লিডারের কৌশলটির প্রতি আরও বেশি মনোযোগ দেন। প্রিন্টমনি লিডারের কৌশলটি বাইনান্স ইউএসডিটি চুক্তিতে লেনদেন করা হয়। অনেক অনুসারীদের পর্যবেক্ষণ এবং বিশ্লেষণ থেকে দেখা যায় যে এই উচ্চ-ফ্রিকোয়েন্সি কৌশলটি লিক্স রিপারের নীতির অনুরূপ (নেতা শাওকাও বলেছিলেন যে উচ্চ-ফ্রিকোয়েন্সি কৌশলগুলির নীতিটি অনুরূপ) । তবে একটি স্থিতিশীল বিজয় হার এবং একটি উপযুক্ত লাভ এবং ক্ষতি অনুপাত অর্জনের জন্য কিছু সূক্ষ্ম হতে হবে।

তাই, আমি সাহায্য করতে পারিনি কিন্তু যাদু পরিবর্তন করতে পারি। যদিও যাদু পরিবর্তন কৌশল প্রভাব নেতৃবৃন্দের কৌশল তুলনায় অনেক খারাপ ছিল। এটি উচ্চ ফ্রিকোয়েন্সি কৌশল জন্য একটি শেখার অনুশীলন। 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)
    }
}

কৌশল পরিবর্তনের ধারণা

কৌশলটি হ'ল বাইনান্স ইউএসডিটি চুক্তি বাজারে বাণিজ্য করার পরিকল্পনা করা, যা একমুখী অবস্থানগুলিকে সমর্থন করে। অতএব, কৌশলটি একমুখী অবস্থানের বৈশিষ্ট্য অনুসারে সংশোধন করা হয় (একমুখী অবস্থানটি কৌশলটি সংশোধন করার জন্য আরও সুবিধাজনক), আমরা অবস্থানটি বন্ধ করার কথা বিবেচনা করি না, আমরা কেবল বিক্রয় এবং ক্রয় বিবেচনা করি। ধারণাটি লিক্সরিপারের স্পট সংস্করণের কাছাকাছি।

কৌশলটি মূলত স্বল্পমেয়াদী মূল্য প্রবণতা অগ্রগতির মূল মানদণ্ড বজায় রাখে, যা পরামিতি দ্বারা নিয়ন্ত্রিত হয়।burstThresholdPCT, যার ভিত্তিতে বিচার করা যায় যে, স্বল্পমেয়াদী মূল্যbullঅথবাbear.

কৌশলটি মূল মডিউলগুলির কিছু নির্মূল করে, যেমন ব্যালেন্স মডিউল। বৃহত্তর পরিবর্তন হ'ল অর্ডার বইয়ের নির্মাতারা, লেনদেনের জন্য অপেক্ষা করছে। এটি একটি বিশৃঙ্খল লং/শর্ট গেমে কম খরচে একটি পজিশন খোলার, স্বল্পমেয়াদী প্রবণতা অনুসরণ করার এবং স্বল্পমেয়াদী প্রবণতা বিপরীত হলে পজিশনটি বন্ধ করার এবং একটি বিপরীত অপেক্ষাকৃত আদেশের সাথে অবস্থানটি খোলার প্রত্যাশা করা হয়।

কৌশলটি সংক্ষিপ্ত এবং সহজ কারণ এটি অন্যান্য অকেজো কোড সরিয়ে নিয়েছে। যদিও কৌশলটি এমন একটি কৌশল যা অর্থ উপার্জন করে না, বা এমনকি অর্থ হারাতে পারে না, তবে উচ্চ-ফ্রিকোয়েন্সি কৌশল শিখছেন এমন এফএমজি হিসাবে, উচ্চ-ফ্রিকোয়েন্সি কৌশলটির আচরণ পর্যবেক্ষণ করা, বাজারের মাইক্রো-আইনগুলি পর্যবেক্ষণ করা এমন একটি মডেল যা ব্যবহার করা যেতে পারে। প্রোগ্রাম ট্রেডিং এবং পরিমাণগত ট্রেডিংয়ের ভিত্তি হিসাবে প্রচুর অনুশীলন, অভিজ্ঞতা, তত্ত্বের প্রয়োজন।

কৌশল অপ্টিমাইজেশান

বর্তমানে, অপ্টিমাইজেশনের জন্য কোন ভাল দিক খুঁজে পাওয়া যায়নি। আগ্রহী কেউ আপনার মন্তব্য রেখে দিতে পারেন এবং একসাথে আলোচনা করতে পারেন।

কৌশলঃhttps://www.fmz.com/strategy/260806

এই কৌশলটি শুধুমাত্র শেখার জন্য, যখন বাজার খুব বেশি আশাবাদী না হয় তখন আসল বট ক্ষতির সম্মুখীন হতে পারে।