मार्जिन कॉल जोखिम प्रबंधन रणनीति के साथ लीवरेज्ड पोजीशन साइजिंग

लेखक:चाओझांग, दिनांकः 2023-12-26 16:21:58
टैगः

img

अवलोकन

यह रणनीति बाजार के महत्वपूर्ण उतार-चढ़ाव के दौरान पदों को बंद करने के लिए उच्च लाभप्रदता और मार्जिन कॉल शर्तों को निर्धारित करके जोखिम का प्रबंधन करती है।

रणनीति तर्क

  1. उच्च लीवरेज सेट करें, उदाहरण के लिए 4x
  2. मार्जिन कॉल स्तर को परिभाषित करें, जैसे $25,000
  3. जब इक्विटी मार्जिन कॉल स्तर से नीचे गिरती है तो नए ट्रेडों को खोलना बंद करें
  4. जब मार्जिन कॉल ट्रिगर होता है तो सभी पदों को बंद करें क्योंकि इक्विटी गिरती रहती है

ऐसा करने से, रणनीति मार्जिन कॉल जोखिमों को रोकने के लिए तेजी से बाजार की चाल के दौरान समय में नुकसान को कम कर सकती है।

लाभ विश्लेषण

  1. व्यक्तिगत जोखिम सहिष्णुता के आधार पर लचीला लाभ अनुकूलन
  2. मार्जिन कॉल तंत्र खाता ब्लोअप को रोकता है
  3. जोखिमों को कम करने के लिए उच्च लाभप्रदता के साथ समय पर स्टॉप लॉस

जोखिम विश्लेषण

  1. लाभ और जोखिम दोनों को बढ़ाता है
  2. मार्जिन कॉल स्तर को स्टॉप लॉस के साथ संरेखित करने की आवश्यकता है
  3. स्टॉप लॉस के लिए स्लिप जोखिम

जोखिमों को लीवरेज को समायोजित करके, मार्जिन कॉल और स्टॉप लॉस को संरेखित करके, स्टॉप लॉस को अनुकूलित करके, आदि से कम किया जा सकता है।

अनुकूलन दिशाएँ

  1. विपरीत रुझान व्यापार से बचने के लिए प्रवृत्ति फ़िल्टर जोड़ें
  2. फिसलने से बचने के लिए स्टॉप लॉस को अनुकूलित करें
  3. कुछ सत्रों में ट्रेडों से बचने के लिए ट्रेडिंग घंटे फ़िल्टर सेट करें
  4. गतिशील रूप से मापदंडों को समायोजित करने के लिए मशीन लर्निंग मॉडल को शामिल करें

सारांश

यह रणनीति खाता ब्लोअप को रोकने के लिए लीवरेज और मार्जिन कॉल सेटिंग्स के साथ जोखिम का प्रबंधन करती है। हालांकि, उच्च लीवरेज जोखिम को भी बढ़ाता है। ट्रेंड वैलिडेशन, स्टॉप लॉस ऑप्टिमाइजेशन और ट्रेडिंग घंटे नियंत्रण जैसे अतिरिक्त प्रयास जोखिम को और कम करने में मदद कर सकते हैं। मशीन लर्निंग जैसी जटिल तकनीकों का भी लाभ उठाया जा सकता है ताकि पैरामीटर को गतिशील रूप से अनुकूलित किया जा सके और लाभप्रदता और जोखिम प्रबंधन के बीच संतुलन बना सके।


/*backtest
start: 2023-11-25 00:00:00
end: 2023-12-25 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
//@version=4
//@author=Daveatt

// Breakout on 2H high/low break Strategy

SystemName = "Leverage Strategy"
TradeId = "🙏"

InitCapital             = 100000
InitPosition            = 1
UseMarginCall           = input(true, title="Use Margin Call?")
MarginValue             = input(25000, title="Margin Value", type=input.float)
// use 1 for no leverage
// use 0.1 for be underleveraged and bet 1/10th of a pip value
// use any value > 1 for full-degen mode
UseLeverage             = input(true, title="Use Leverage")
LeverageValue           = input(4, title="Leverage mult (1 for no leverage)", minval=0.1, type=input.float)
// Risk Management
UseRiskManagement       = input(true, title="Use Risk Management?")
// ticks = 1/10th of a pip value
StopLoss                = input(5, title="Stop Loss in ticks value", type=input.float)
TakeProfit              = input(500, title="Take Profit in ticks value", type=input.float)

InitCommission = 0.075
InitPyramidMax = 1
CalcOnorderFills = false
CalcOnTick = true
DefaultQtyType = strategy.cash
DefaultQtyValue = strategy.cash
Currency = currency.USD
Precision = 2
Overlay=false
MaxBarsBack=3000

strategy
 (
 title=SystemName, 
 shorttitle=SystemName, 
 overlay=Overlay 
 )

//////////////////////////// UTILITIES ///////////////////////////

f_print(_txt, _condition) =>

    var _lbl = label(na)
    label.delete(_lbl)

    if _condition
        // saving the candle where we got rekt :(
        _index = barssince(_condition)
        _lbl := label.new(bar_index - _index, highest(100), _txt, xloc.bar_index, yloc.price, size = size.normal, style=label.style_labeldown)

//////////////////////////// STRATEGY LOGIC ///////////////////////////

// Date filterigng
_Date       = input(true, title="[LABEL] DATE")
FromYear = input(2019, "From Year", minval=1900),   FromMonth = input(12, "From Month", minval=1, maxval=12),    FromDay = input(1, "From Day", minval=1, maxval=31)
ToYear = input(2019, "To Year", minval=1900),       ToMonth = input(12, "To Month", minval=1, maxval=12),        ToDay = input(9, "To Day", minval=1, maxval=31)
FromDate = timestamp(FromYear, FromMonth, FromDay, 00, 00)     
ToDate = timestamp(ToYear, ToMonth, ToDay, 23, 59)
TradeDateIsAllowed = true

// non-repainting security version
four_hours_H     = security(syminfo.tickerid, '240', high[1], lookahead=true)
four_hours_L     = security(syminfo.tickerid, '240', low[1], lookahead=true)
buy_trigger     = crossover(close, four_hours_H)
sell_trigger    = crossunder(close, four_hours_L)

// trend states
since_buy  = barssince(buy_trigger)
since_sell = barssince(sell_trigger)
buy_trend  = since_sell > since_buy
sell_trend = since_sell < since_buy 

change_trend = (buy_trend and sell_trend[1]) or (sell_trend and buy_trend[1])

// plot(four_hours_H, title="4H High",  linewidth=2, color=#3c91c2, style=plot.style_linebr, transp=0,
//  show_last=1, trackprice=true)
// plot(four_hours_L, title="4H Low",  linewidth=2, color=#3c91c2, style=plot.style_linebr, transp=0,
//  show_last=1, trackprice=true)

plot(strategy.equity, color=color.blue, linewidth=3, title="Strategy Equity")

// get the entry price
entry_price = valuewhen(buy_trigger or sell_trigger, close, 0)

// SL and TP

SL_price    = buy_trend ? entry_price - StopLoss    : entry_price + StopLoss
is_SL_hit   = buy_trend ? crossunder(low, SL_price) : crossover(high, SL_price) 

TP_price    = buy_trend ? entry_price + TakeProfit  : entry_price - TakeProfit
is_TP_hit   = buy_trend ? crossover(high, TP_price) : crossunder(low, TP_price)

//  Account Margin Management:
f_account_margin_call_cross(_amount)=>
    _return = crossunder(strategy.equity, _amount)

f_account_margin_call(_amount)=>
    _return = strategy.equity <= _amount

is_margin_call_cross    = f_account_margin_call_cross(MarginValue)
is_margin_call          = f_account_margin_call(MarginValue)

plot(strategy.equity, title='strategy.equity', transp=0, linewidth=4)
//plot(barssince(is_margin_call ), title='barssince(is_margin_call)', transp=100)

can_trade = iff(UseMarginCall, not is_margin_call, true)
trade_size  = InitPosition * (not UseLeverage ? 1 : LeverageValue)

// We can take the trade if not liquidated/margined called/rekt

buy_final   = can_trade and buy_trigger and TradeDateIsAllowed
sell_final  = can_trade and sell_trigger and TradeDateIsAllowed

close_long  = buy_trend  and 
 (UseRiskManagement and (is_SL_hit or is_TP_hit)) or sell_trigger

close_short = sell_trend and 
 (UseRiskManagement and (is_SL_hit or is_TP_hit)) or buy_trigger

strategy.entry(TradeId + ' B', long=true, qty=trade_size, when=buy_final)
strategy.entry(TradeId + ' S', long=false, qty=trade_size, when=sell_final)
strategy.close(TradeId + ' B', when=close_long)
strategy.close(TradeId + ' S', when=close_short)

// FULL DEGEN MODE ACTIVATED
// Margin called - Broker closing your account
strategy.close_all(when=is_margin_call)

if UseMarginCall and is_margin_call_cross
    f_print("☠️REKT☠️", is_margin_call_cross)


अधिक