dYdX কৌশল নকশা উদাহরণ

dYdX কৌশল নকশা উদাহরণ

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

প্রথমে খনি ভাগ করুন

নিবন্ধে কৌশল খনির স্ক্রিনশট.

যারা ভাল খনির কৌশলগত ধারণা আছে তাদের স্বাগতম!

র্যান্ডম ট্রেডিং কৌশল ডিজাইন

আসুন একটি মস্তিষ্ক ঝড় আছে! আমরা সূচক বা দাম তাকান ছাড়া এলোমেলোভাবে অর্ডার স্থাপন করার জন্য একটি কৌশল ডিজাইন করার পরিকল্পনা করছি। অর্ডার দীর্ঘ এবং সংক্ষিপ্ত কাজ ছাড়া আর কিছুই নয়, যা সম্ভাব্যতা উপর বাজি হয়। তারপর আমরা 1 থেকে 100 পর্যন্ত এলোমেলো সংখ্যা ব্যবহার করে দীর্ঘ বা সংক্ষিপ্ত কাজ কিনা তা নির্ধারণ করতে।

লং করার শর্তঃ 1 থেকে 50 পর্যন্ত র্যান্ডম সংখ্যা। সংক্ষিপ্ত করার শর্তঃ 51 থেকে 100 পর্যন্ত র্যান্ডম সংখ্যা।

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

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

ঠিক আছে, কৌশলটা ঠিক আছে, এটা সহজ।

ডিজাইনের উৎস কোডঃ

var openPrice = 0 
var ratio = 1
var totalEq = null 
var nowEq = null 

function cancelAll() {
    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, orders[i])
            Sleep(500)
        }
        Sleep(500)
    }
}

function main() {
    if (isReset) {
        _G(null)
        LogReset(1)
        LogProfitReset()
        LogVacuum()
        Log("reset all data", "#FF0000")
    }

    exchange.SetContractType(ct)

    var initPos = _C(exchange.GetPosition)
    if (initPos.length != 0) {
        throw "Position detected when starting the strategy!"
    }
    
    exchange.SetPrecision(pricePrecision, amountPrecision)
    Log("setPrecision", pricePrecision, amountPrecision)
    
    if (!IsVirtual()) {
        var recoverTotalEq = _G("totalEq")
        if (!recoverTotalEq) {
            var currTotalEq = _C(exchange.GetAccount).Balance   // equity
            if (currTotalEq) {
                totalEq = currTotalEq
                _G("totalEq", currTotalEq)
            } else {
                throw "fail to obtain the initial equity"
            }
        } else {
            totalEq = recoverTotalEq
        }
    } else {
        totalEq = _C(exchange.GetAccount).Balance
    }
    
    while (1) {
        if (openPrice == 0) {
            // update account information, and calculate the profit
            var nowAcc = _C(exchange.GetAccount)
            nowEq = IsVirtual() ? nowAcc.Balance : nowAcc.Balance  // equity
            LogProfit(nowEq - totalEq, nowAcc)
            
            var direction = Math.floor((Math.random()*100)+1)   // 1~50 , 51~100
            var depth = _C(exchange.GetDepth)
            if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                Sleep(1000)
                continue 
            }
            if (direction > 50) {
                // long
                openPrice = depth.Bids[1].Price
                exchange.SetDirection("buy")
                exchange.Buy(Math.abs(openPrice) + slidePrice, amount * ratio)
            } else {
                // short
                openPrice = -depth.Asks[1].Price
                exchange.SetDirection("sell")
                exchange.Sell(Math.abs(openPrice) - slidePrice, amount * ratio)
            }       
            Log("place", direction > 50 ? "buy order" : "sell order", "，price:", Math.abs(openPrice))
            continue
        }

        var orders = _C(exchange.GetOrders)
        if (orders.length == 0) {
            var pos = _C(exchange.GetPosition)
            if (pos.length == 0) {
                openPrice = 0
                continue
            }
            
            // detect close positions 
            while (1) {
                var depth = _C(exchange.GetDepth)
                if (depth.Asks.length <= 2 || depth.Bids.length <= 2) {
                    Sleep(1000)
                    continue 
                }
                var stopLossPrice = openPrice > 0 ? Math.abs(openPrice) - stopLoss : Math.abs(openPrice) + stopLoss 
                var stopProfitPrice = openPrice > 0 ? Math.abs(openPrice) + stopProfit : Math.abs(openPrice) - stopProfit
                var winOrLoss = 0 // 1 win , -1 loss 
                
                // plot 
                $.PlotLine("bid", depth.Bids[0].Price)
                $.PlotLine("ask", depth.Asks[0].Price)
                
                // stop loss
                if (openPrice > 0 && depth.Bids[0].Price < stopLossPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)
                    winOrLoss = -1
                } else if (openPrice < 0 && depth.Asks[0].Price > stopLossPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = -1
                }
                
                // stop profit 
                if (openPrice > 0 && depth.Bids[0].Price > stopProfitPrice) {
                    exchange.SetDirection("closebuy")
                    exchange.Sell(depth.Bids[0].Price - slidePrice, pos[0].Amount)  
                    winOrLoss = 1
                } else if (openPrice < 0 && depth.Asks[0].Price < stopProfitPrice) {
                    exchange.SetDirection("closesell")
                    exchange.Buy(depth.Asks[0].Price + slidePrice, pos[0].Amount)
                    winOrLoss = 1
                }
                
                // detect pending orders 
                Sleep(2000)
                var orders = _C(exchange.GetOrders)                
                if (orders.length == 0) {
                    pos = _C(exchange.GetPosition)
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }                    
                } else {
                    // cancel pending orders
                    cancelAll()
                    Sleep(2000)
                    pos = _C(exchange.GetPosition)
                    // after canceling, update positions, which needs to be detected again 
                    if (pos.length == 0) {
                        if (winOrLoss == -1) {
                            ratio++
                        } else if (winOrLoss == 1) {
                            ratio = 1
                        }
                        break
                    }    
                }
                
                var tbl = {
                    "type" : "table", 
                    "title" : "info", 
                    "cols" : ["totalEq", "nowEq", "openPrice", "bid1Price", "ask1Price", "ratio", "pos.length"], 
                    "rows" : [], 
                }
                tbl.rows.push([totalEq, nowEq, Math.abs(openPrice), depth.Bids[0].Price, depth.Asks[0].Price, ratio, pos.length])
                tbl.rows.push(["pos", "type", "amount", "price", "--", "--", "--"])
                for (var j = 0 ; j < pos.length ; j++) {
                    tbl.rows.push([j, pos[j].Type, pos[j].Amount, pos[j].Price, "--", "--", "--"])
                }
                LogStatus(_D(), "\n", "`" + JSON.stringify(tbl) + "`")
            }
        } else {
            // cancel pending orders 
            // reset openPrice
            cancelAll()
            openPrice = 0
        }
        Sleep(1000)
    }
}

কৌশলগত পরামিতি:

ঠিক আছে! কৌশল একটি নাম প্রয়োজন, এবং এর নাম দিন "Guess Which is Bigger (dYdX version) "

ব্যাকটেস্ট

ব্যাকটেস্ট শুধু রেফারেন্সের জন্য! এটি মূলত কৌশলটিতে কোনও বাগ আছে কিনা তা পরীক্ষা করার জন্য; বাইনারেন্স ফিউচারগুলির সাথে ব্যাকটেস্ট।

ব্যাকটেস্ট শেষ, কোন বাগ নেই, কিন্তু আমার মনে হয় ব্যাকটেস্ট সিস্টেমটি মিলে গেছে...

একটি বটে চালান

এই কৌশল শুধুমাত্র শেখার এবং রেফারেন্সের জন্য।করো না!! করো নাএটাকে একটা আসল বোট বানাতে ব্যবহার করো!