ترمیم شدہ لیک ہارویسٹر کے نقطہ نظر سے اعلی تعدد حکمت عملی کے ڈیزائن پر تبادلہ خیال کرنا

پچھلے مضامین میں، ہم نے لیک ہارویسٹر ہائی فریکوئنسی حکمت عملی کے اصل اسپاٹ ورژن کے آئیڈیاز اور کوڈ کے نفاذ کا تجزیہ کیا۔

لیک ہارویسٹر کی حکمت عملی کا تجزیہ (1) لیک ہارویسٹر کی حکمت عملی کا تجزیہ (2)

کرنسی کے دائرے کی مقدار کے بارے میں بہت سے صارفین زیادہ فکر مند ہیں۔print moneyباس کی حکمت عملی،print moneyباس کی حکمت عملی بائننس پر USDT معاہدوں کی تجارت کرنا ہے۔ بہت سے پیروکاروں کے مشاہدات اور تجزیوں سے یہ دیکھا جا سکتا ہے کہ یہ اعلی تعدد کی حکمت عملی لیک ہارویسٹر کے اصول سے ملتی جلتی ہے (کاو شین نے یہ بھی کہا کہ اعلی تعدد کی حکمت عملیوں کے اصول نسبتاً قریب ہیں)۔ لیکن یقینی طور پر ایسی باریکیاں ہیں جو اس بات کو یقینی بنا سکتی ہیں کہ حکمت عملی میں جیتنے کی مستحکم شرح اور منافع اور نقصان کا مناسب تناسب ہے۔

اس لیے ایڈیٹر جو اپنی صلاحیتوں کو دکھانے کے لیے کھجلی کر رہا تھا وہ کچھ تبدیلیاں کرنے میں مدد نہیں کر سکا، حالانکہ ترمیم شدہ حکمت عملی کا اثر آقاؤں کی حکمت عملیوں سے کچل کر راکھ ہو گیا تھا۔ لیکن اسے اعلی تعدد کی حکمت عملیوں کے سیکھنے اور مشق کے طور پر بھی سمجھا جا سکتا ہے دلچسپی رکھنے والے FMZers ایک ساتھ بات چیت اور سیکھ سکتے ہیں۔

ترمیم شدہ لیک ہارویسٹر

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

حکمت عملی میں ترمیم کے خیالات

Binance USDT کنٹریکٹ مارکیٹ میں تجارت کو استعمال کرنے کی حکمت عملی یہ ہے کہ بائنانس کنٹریکٹس ون وے پوزیشنز کو سپورٹ کریں۔ اس لیے، حکمت عملی کو یک طرفہ پوزیشنوں کی خصوصیات کے مطابق تبدیل اور ڈیزائن کیا گیا ہے (ایک طرفہ پوزیشنیں حکمت عملی میں ترمیم کے لیے زیادہ آسان ہیں)، بند ہونے والی پوزیشنوں پر غور کیے بغیر، صرف خرید و فروخت پر غور کریں۔ یہ خیال لیک ہارویسٹر کے اسپاٹ ورژن کے قریب ہے۔

حکمت عملی بنیادی طور پر اصل قلیل مدتی قیمت کے رجحان کے پیش رفت کے فیصلے کے معیار کو برقرار رکھتی ہے، اور قلیل مدتی قیمت کی پیش رفت کی حد کا تعین پیرامیٹر کے ذریعے کیا جاتا ہے۔burstThresholdPctکنٹرول، اس فیصلے کی شرط کے مطابق، مختصر مدت کی قیمت ہےbull(گائے)، یاbear(ریچھ)۔

حکمت عملی اصل ورژن سے کچھ ماڈیولز کو ہٹا دیتی ہے، جیسے بیلنس ماڈیول۔ سب سے بڑی تبدیلی یہ ہے کہ آرڈر بک میں آرڈر دینے اور لین دین کے مکمل ہونے کا انتظار کرنے کے لیے آرڈر میں تبدیلی کی گئی ہے۔ افراتفری والے بازار میں کم قیمت پر پوزیشن کھولنے کی توقع کی جاتی ہے جہاں طویل اور مختصر کھیل سخت ہوتے ہیں، قلیل مدتی رجحان کی پیروی کریں، قلیل مدتی رجحان کے الٹ جانے پر پوزیشن کو بند کریں، اور ریورس آرڈرز کے ساتھ پوزیشنیں کھولنا جاری رکھیں۔ .

حکمت عملی دوسرے بیکار کوڈز کو ہٹا دیتی ہے لہذا یہ بہت مختصر اور آسان ہے۔ اگرچہ حکمت عملی منافع بخش نہیں ہے اور یہاں تک کہ پیسہ بھی کھو دیتا ہے، یہ ایک ایسا ماڈل ہے جسے FMZers اعلی تعدد کی حکمت عملی سیکھنے، اعلی تعدد کی حکمت عملیوں کے رویے کا مشاہدہ کرنے اور مارکیٹ کے مائیکرو قوانین کا مشاہدہ کرنے کے لیے استعمال کر سکتے ہیں۔ الگورتھمک ٹریڈنگ اور مقداری تجارت کو بنیاد کے طور پر بہت زیادہ مشق، تجربہ اور تھیوری کی ضرورت ہوتی ہے۔

تھوڑی دیر کے لیے دوڑیں۔

یہ دیکھا جا سکتا ہے کہ جب مارکیٹ فعال نہ ہو تو پوزیشنوں کو کھولنا اور بند کرنا زیادہ مشکل ہوتا ہے۔

حکمت عملی کی اصلاح

فی الحال، کوئی اچھی اصلاح کی سمت نہیں ملی ہے۔ جو طلباء دلچسپی رکھتے ہیں وہ ایک ساتھ بات کرنے اور بات چیت کرنے کا خیرمقدم کرتے ہیں۔

حکمت عملی کا پتہ: https://www.fmz.com/strategy/260806

یہ حکمت عملی صرف سیکھنے کے مقاصد کے لیے ہے، اور اگر مارکیٹ فلیٹ ہے تو حقیقی تجارت کے نتیجے میں نقصان ہو سکتا ہے۔