خود کو اپنانے والی کوانٹم گرڈ ٹریڈنگ حکمت عملی

مصنف:چاؤ ژانگ، تاریخ: 2024-02-02 18:08:22
ٹیگز:

img

جائزہ

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

حکمت عملی منطق

  1. ان پٹ پیرامیٹرز کی بنیاد پر گرڈ کی حدود اور گرڈ لائن قیمت صف کا حساب لگائیں.

  2. جب قیمت بغیر متعلقہ احکامات کے گرڈ لائن سے نیچے آجاتی ہے تو ، گرڈ لائن کی قیمت پر طویل احکامات دیئے جائیں گے۔ جب قیمت موجودہ پوزیشن کے ساتھ پچھلی گرڈ لائن (پہلی خارج) سے اوپر بڑھ جاتی ہے تو ، پچھلی لائن کے لمبے احکامات بند کردیئے جائیں گے۔

  3. اگر آٹو ایڈجسٹمنٹ فعال ہے تو، تازہ ترین شمعدان کے اعداد و شمار کی بنیاد پر گرڈ اوپری / نچلی حدود، گرڈ اسپیسنگ اور گرڈ صفوں کو باقاعدگی سے دوبارہ شمار کیا جائے گا.

فوائد کا تجزیہ

  1. غیر مستحکم مارکیٹ کے درمیان مستحکم منافع حاصل کریں۔ مجموعی منافع حاصل کرنے کے لئے مختلف قیمتوں کی سطح پر لمبی / مختصر پوزیشنیں بیچوں میں بنائی اور بند کی جاتی ہیں۔

  2. دستی اور خودکار پیرامیٹر ایڈجسٹمنٹ دونوں کی حمایت کریں۔ دستی ایڈجسٹمنٹ بہتر کنٹرول فراہم کرتی ہے لیکن مداخلت کی ضرورت ہوتی ہے۔ خودکار ایڈجسٹمنٹ کام کے بوجھ کو کم کرتی ہے اور بدلتی ہوئی مارکیٹ کی حرکیات کو اپناتی ہے۔

  3. جب قیمت تمام گرڈ لائنوں کو توڑتی ہے تو ، خطرات پر قابو پایا جاتا ہے۔

  4. ہر تجارت میں منافع / نقصان کو ایڈجسٹ کرنے کے لئے گرڈ اسپیسنگ کو ٹیون کریں۔ چھوٹا اسپیسنگ ہر تجارت میں نمائش کو کم کرتا ہے۔

خطرے کا تجزیہ

  1. پھنس جانے کا خطرہ۔ گرڈ رینج کے اندر قیمتوں میں کثرت سے اتار چڑھاؤ نقصانات کا باعث بن سکتا ہے۔

  2. مناسب ابتدائی سرمایہ کی ضرورت ہے۔ ناکافی فنڈنگ کافی نیٹ لائنوں کی حمایت نہیں کرسکتی ہے۔

  3. انتہائی گرڈ نمبر منافع کو نقصان پہنچاتے ہیں۔ بہت کم گرڈ اتار چڑھاؤ کا بھرپور فائدہ اٹھانے میں ناکام رہتے ہیں جبکہ بہت زیادہ گرڈ فی تجارت کم سے کم منافع کا باعث بنتے ہیں۔ زیادہ سے زیادہ ترتیبات کا تعین کرنے کے لئے وسیع پیمانے پر جانچ کی ضرورت ہے۔

  4. آٹو ایڈجسٹمنٹ قیمت میں ہیرا پھیری کا خطرہ ہے۔ حالیہ موم بتیوں پر انحصار کرتا ہے جن پر قلیل مدتی قیمت کے آپریشن سے اثر پڑ سکتا ہے۔

اصلاح

  1. سٹاپ نقصان کی منطق متعارف کروانا جیسے ٹریلنگ سٹاپ نقصان ہر سمت میں نیچے کی طرف خطرے کو مزید محدود کرنے کے لئے.

  2. مشین لرننگ کے ذریعے گرڈ پیرامیٹرز کو بہتر بنائیں۔ مارکیٹ کے حالات میں مختلف پیرامیٹرز کی جانچ کریں اور بہترین ، موافقت پذیر پیرامیٹرز حاصل کرنے کے لئے ML ماڈلز کو تربیت دیں۔

  3. اضافی تکنیکی اشارے شامل کریں۔ گرڈ کی مقدار اور پیرامیٹر ٹیوننگ کی رہنمائی کے لئے MACD اور RSI جیسے اشارے کے ساتھ موجودہ رجحان کی طاقت کا اندازہ کریں۔

  4. زیادہ سے زیادہ اجازت یافتہ ڈراؤنڈ فیصد مقرر کرکے خطرے کے کنٹرول کو بہتر بنائیں۔ مزید نقصانات کو روکنے کے لئے جب حد کو توڑا جاتا ہے تو حکمت عملی کو غیر فعال کریں۔

نتیجہ

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


/*backtest
start: 2024-01-02 00:00:00
end: 2024-02-01 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//@version=4
strategy("(IK) Grid Script", overlay=true, pyramiding=14, close_entries_rule="ANY", default_qty_type=strategy.cash, initial_capital=100.0, currency="USD", commission_type=strategy.commission.percent, commission_value=0.1)
i_autoBounds    = input(group="Grid Bounds", title="Use Auto Bounds?", defval=true, type=input.bool)                             // calculate upper and lower bound of the grid automatically? This will theorhetically be less profitable, but will certainly require less attention
i_boundSrc      = input(group="Grid Bounds", title="(Auto) Bound Source", defval="Hi & Low", options=["Hi & Low", "Average"])     // should bounds of the auto grid be calculated from recent High & Low, or from a Simple Moving Average
i_boundLookback = input(group="Grid Bounds", title="(Auto) Bound Lookback", defval=250, type=input.integer, maxval=500, minval=0) // when calculating auto grid bounds, how far back should we look for a High & Low, or what should the length be of our sma
i_boundDev      = input(group="Grid Bounds", title="(Auto) Bound Deviation", defval=0.10, type=input.float, maxval=1, minval=-1)  // if sourcing auto bounds from High & Low, this percentage will (positive) widen or (negative) narrow the bound limits. If sourcing from Average, this is the deviation (up and down) from the sma, and CANNOT be negative.
i_upperBound    = input(group="Grid Bounds", title="(Manual) Upper Boundry", defval=0.285, type=input.float)                      // for manual grid bounds only. The upperbound price of your grid
i_lowerBound    = input(group="Grid Bounds", title="(Manual) Lower Boundry", defval=0.225, type=input.float)                      // for manual grid bounds only. The lowerbound price of your grid.
i_gridQty       = input(group="Grid Lines",  title="Grid Line Quantity", defval=8, maxval=15, minval=3, type=input.integer)       // how many grid lines are in your grid

f_getGridBounds(_bs, _bl, _bd, _up) =>
    if _bs == "Hi & Low"
        _up ? highest(close, _bl) * (1 + _bd) : lowest(close, _bl)  * (1 - _bd)
    else
        avg = sma(close, _bl)
        _up ? avg * (1 + _bd) : avg * (1 - _bd)

f_buildGrid(_lb, _gw, _gq) =>
    gridArr = array.new_float(0)
    for i=0 to _gq-1
        array.push(gridArr, _lb+(_gw*i))
    gridArr

f_getNearGridLines(_gridArr, _price) =>
    arr = array.new_int(3)
    for i = 0 to array.size(_gridArr)-1
        if array.get(_gridArr, i) > _price
            array.set(arr, 0, i == array.size(_gridArr)-1 ? i : i+1)
            array.set(arr, 1, i == 0 ? i : i-1)
            break
    arr

var upperBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true) : i_upperBound  // upperbound of our grid
var lowerBound      = i_autoBounds ? f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false) : i_lowerBound // lowerbound of our grid
var gridWidth       = (upperBound - lowerBound)/(i_gridQty-1)                                                       // space between lines in our grid
var gridLineArr     = f_buildGrid(lowerBound, gridWidth, i_gridQty)                                                 // an array of prices that correspond to our grid lines
var orderArr        = array.new_bool(i_gridQty, false)                                                              // a boolean array that indicates if there is an open order corresponding to each grid line

var closeLineArr    = f_getNearGridLines(gridLineArr, close)                                                        // for plotting purposes - an array of 2 indices that correspond to grid lines near price
var nearTopGridLine = array.get(closeLineArr, 0)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line above current price
var nearBotGridLine = array.get(closeLineArr, 1)                                                                    // for plotting purposes - the index (in our grid line array) of the closest grid line below current price
strategy.initial_capital = 50000
for i = 0 to (array.size(gridLineArr) - 1)
    if close < array.get(gridLineArr, i) and not array.get(orderArr, i) and i < (array.size(gridLineArr) - 1)
        buyId = i
        array.set(orderArr, buyId, true)
        strategy.entry(id=tostring(buyId), long=true, qty=(strategy.initial_capital/(i_gridQty-1))/close, comment="#"+tostring(buyId))
    if close > array.get(gridLineArr, i) and i != 0
        if array.get(orderArr, i-1)
            sellId = i-1
            array.set(orderArr, sellId, false)
            strategy.close(id=tostring(sellId), comment="#"+tostring(sellId))

if i_autoBounds
    upperBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, true)
    lowerBound  := f_getGridBounds(i_boundSrc, i_boundLookback, i_boundDev, false)
    gridWidth   := (upperBound - lowerBound)/(i_gridQty-1)
    gridLineArr := f_buildGrid(lowerBound, gridWidth, i_gridQty)

closeLineArr    := f_getNearGridLines(gridLineArr, close)
nearTopGridLine := array.get(closeLineArr, 0)
nearBotGridLine := array.get(closeLineArr, 1)



مزید