1. 사각형
  2. 이중 강한 트렌드 추적 스톱 손실 전략

이중 강한 트렌드 추적 스톱 손실 전략

저자:차오장, 날짜: 2023-11-16 15:50:54
태그:

img

전반적인 설명

이 전략은 슈퍼트렌드 및 상대적 강도 지수를 기반으로 두 가지 트렌드 추적 메커니즘을 사용하여 시장의 트렌드를 정확하게 결정하고 합리적인 스톱 로스 및 영업 포인트를 설정하도록 설계되었습니다. 이 전략은 시장 움직임을 추적하고 트렌드를 기반으로 영업 포인트를 취하는 스톱 로스 포인트를 갖추고 있으며 개별 거래의 위험을 효과적으로 제어하고 트렌딩 시장에서 매우 강력한 수익을 얻을 수 있습니다.

전략 논리

  1. 슈퍼트렌드를 계산하여 주요 트렌드 방향을 결정합니다. 슈퍼트렌드는 트렌드 방향을 정확하게 판단하고 이상적인 입구 지점을 줄 수 있습니다.

  2. 트렌드 판단에 보조 지표로서 상대 강도 지수 (RSI) 를 계산하십시오. 높은 RSI는 황소 시장에서 상승 추세를 나타냅니다. 낮은 RSI는 곰 시장에서 하락 추세를 나타냅니다.

  3. 클로즈 가격이 슈퍼트렌드 라인을 넘어서면 장거리, 클로즈 가격이 슈퍼트렌드 라인을 넘어서면 단거리입니다.

  4. 합리적으로 스톱 로스를 설정하고 이윤을 취하십시오. 장기간에 걸을 때 슈퍼 트렌드 라인을 스톱 로스로 설정하고 슈퍼 트렌드 라인을 합당한 이윤으로 설정하십시오. 단위로 갈 때 슈퍼 트렌드 라인을 스톱 로스로 설정하고 슈퍼 트렌드 라인을 마이너스 합당한 이윤으로 설정하십시오.

  5. 스톱 로스 포인트는 시장의 변동에 따라 변동합니다. 시장이 유리한 방향으로 움직일 때, 스톱 로스 라인은 이익을 확보하기 위해 유리한 방향으로 이동합니다.

  6. RSI가 슈퍼 트렌드와 일치할 때만 트레이드를 입력하십시오. 이는 현재 추세가 더 강하다는 것을 나타냅니다. RSI가 슈퍼 트렌드에서 벗어날 때 입력하지 마십시오. 이는 잠재적 인 트렌드 반전을 나타냅니다.

이점 분석

  • 이중 트렌드 판단 메커니즘은 잘못된 신호를 줄이고 전략의 안정성을 향상시킬 수 있습니다.

  • 스톱 러스 포인트는 트렌드에 따라 움직여 수익 잠금을 극대화하고 조기 스톱 러스를 피합니다.

  • RSI의 적용은 약한 거래 신호를 필터링합니다.

  • 합리적인 수익 포지셔닝은 수익을 극대화시킵니다.

  • 조정 가능한 전략 매개 변수는 다른 제품과 시장 조건에 최적화 될 수 있습니다.

  • 통제 가능한 마감은 전략에 강력한 위험 관리 능력을 부여합니다.

위험 분석

  • 중요한 정책 뉴스와 같은 블랙 스완 이벤트의 경우, 거대한 시장 변동은 포지션을 중단하고 큰 손실을 유발할 수 있습니다. 이벤트 이전에 더 넓은 스톱 손실 포인트 또는 적절한 위치 출퇴가 그러한 위험을 관리하는 데 도움이 될 수 있습니다.

  • 부적절한 매개 변수 설정은 불합리한 스톱 로스로 이어질 수 있으며, 손실을 확대하거나 이익을 줄일 수 있습니다. 반복된 백테스트는 최적의 매개 변수 조합을 찾는 데 도움이 될 수 있습니다.

  • RSI와 슈퍼트렌드 사이의 오차는 범위 제한 시장에서 잘못된 신호를 생성 할 수 있습니다. 거래를 피하고 그러한 경우 명확한 추세를 기다립니다.

최적화 방향

  • 각기 다른 제품에 대한 ATR 기간 매개 변수를 최적화합니다.

  • 더 안정적인 보조 트렌드 조건을 찾기 위해 RSI 설정을 최적화합니다.

  • 볼링거 밴드나 KDJ 같은 다른 지표를 포함시켜 보다 정확한 입출입 규칙을 설정합니다.

  • 수익성을 향상시키기 위해 후속 중지, 단계적 이익 취득, 휘크 중지 등과 같은 다른 수익 전략을 테스트하십시오.

  • 단일 거래 위험을 낮추기 위해 백테스트 결과를 기반으로 포지션 크기를 조정합니다.

결론

이 전략은 전반적으로 강력한 안정성과 수익성을 보여줍니다. 이중 트렌드 판단은 소음을 효과적으로 필터하고 스톱 로스/프로프트 테이크 전략은 수익을 잠금하고 위험을 제어합니다. 매개 변수 및 엔트리/엑시트 조건의 지속적인 최적화는 다른 시장 환경에서 훌륭한 성능을 가능하게합니다. 양적 거래의 우수한 템플릿 전략으로 사용될 수 있으며 심도 있는 연구와 응용 가치가 있습니다.

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

//@version=5
//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ 
//  -----------------------------------------------------------------------------
//  Copyright 2019 Mauricio Pimenta | exit490
//  SuperTrend with Trailing Stop Loss script may be freely distributed under the MIT license.
//
//  Permission is hereby granted, free of charge, 
//  to any person obtaining a copy of this software and associated documentation files (the "Software"), 
//  to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, 
//  publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
//  subject to the following conditions:
//
//  The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
//
//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 
//  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
//  DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 
//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
//  -----------------------------------------------------------------------------
//
//  Authors:  @exit490
//  Revision: v1.0.0
//  Date:     5-Aug-2019
//
//  Description
//  ===========
//  SuperTrend is a moving stop and reversal line based on the volatility (ATR).
//  The strategy will ride up your stop loss when price moviment 1%.
//  The strategy will close your operation when the market price crossed the stop loss.
//  The strategy will close operation when the line based on the volatility will crossed
//
//  The strategy has the following parameters:
//
//  INITIAL STOP LOSS - Where can isert the value to first stop.
//  POSITION TYPE - Where can to select trade position.
//  ATR PERIOD - To select number of bars back to execute calculation
//  ATR MULTPLIER - To add a multplier factor on volatility
//  BACKTEST PERIOD - To select range.
//  
//  -----------------------------------------------------------------------------
//  Disclaimer:
//    1. I am not licensed financial advisors or broker dealers. I do not tell you 
//       when or what to buy or sell. I developed this software which enables you 
//       execute manual or automated trades multplierFactoriplierFactoriple trades using TradingView. The 
//       software allows you to set the criteria you want for entering and exiting 
//       trades.
//    2. Do not trade with money you cannot afford to lose.
//    3. I do not guarantee consistent profits or that anyone can make money with no 
//       effort. And I am not selling the holy grail.
//    4. Every system can have winning and losing streaks.
//    5. Money management plays a large role in the results of your trading. For 
//       example: lot size, account size, broker leverage, and broker margin call 
//       rules all have an effect on results. Also, your Take Profit and Stop Loss 
//       settings for individual pair trades and for overall account equity have a 
//       major impact on results. If you are new to trading and do not understand 
//       these items, then I recommend you seek education materials to further your
//       knowledge.
//
//    YOU NEED TO FIND AND USE THE TRADING SYSTEM THAT WORKS BEST FOR YOU AND YOUR 
//    TRADING TOLERANCE.
//
//    I HAVE PROVIDED NOTHING MORE THAN A TOOL WITH OPTIONS FOR YOU TO TRADE WITH THIS PROGRAM ON TRADINGVIEW.
//    
//    I accept suggestions to improve the script.
//    If you encounter any problems I will be happy to share with me.
//  -----------------------------------------------------------------------------
//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

strategy(title='DEO SESSSION', shorttitle='DEO S', overlay=true, precision=8, calc_on_order_fills=true, calc_on_every_tick=true, backtest_fill_limits_assumption=0, default_qty_type=strategy.percent_of_equity, default_qty_value=100, initial_capital=1000, currency=currency.USD, linktoseries=true)

//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

// === BACKTEST RANGE ===
backTestSectionFrom = input(title='════════════ FROM ════════════', defval=true)


// selected dates 
i_startTime     = input(title="START FILTER", defval=timestamp("02 Jan 2023 00:00 +0000"), group="RISK MANAGEMENT", tooltip="Start date & time to begin searching for setups")
i_endTime       = input(title="END FILTER", defval=timestamp("12 Dec 2100 00:00 +0000"), group="RISK MANAGEMENT", tooltip="End date & time to stop searching for setups")
afterStartDate = true

//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

parameterSection = input(title='══════════ STRATEGY ══════════', defval=true)
// === INPUT TO SELECT POSITION ===
positionType = input.string(defval='LONG', title='Position Type', options=['LONG', 'SHORT'])

// === INPUT TO SELECT INITIAL STOP LOSS
initialStopLossPercent = input.float(defval=3.0, minval=0.0, title='Initial Stop Loss')

// === INPUT TO SELECT BARS BACK
barsBack = input(title='ATR Period', defval=1)

// === INPUT TO SELECT MULTPLIER FACTOR 
multplierFactor = input.float(title='ATR multplierFactoriplier', step=0.1, defval=3.0)


RSI = input.int(title='RSI', defval=7, minval=1, maxval=100)

calcSection = input(title='══════════ LOT CALC ══════════', defval=true)
accountBalance = input.float(title="ACCOUNT BALANCE", defval=250000, minval=1,  group="INPUTS")
entryPrice = input.float(title="ENTRY PRICE", defval=100, minval=1,  group="INPUTS")
slPrice = input.float(title="STOP LOSS PRICE", defval=100, minval=1,  group="INPUTS")
riskPer = input.float(title="RISK USD", defval=1, minval=0.1,  group="INPUTS")
lotSize = input.float(title="LOT SIZE", defval=10, minval=0.1,  group="INPUTS")

RiskSize = riskPer
qtyLongTargetPrice = math.abs((RiskSize / ((entryPrice - slPrice) * syminfo.pointvalue)) / lotSize)

trendcSection = input(title='══════════ TREND LINE ══════════', defval=true)
// ema trend 
tLen = input.int(200, minval=1, title="Trend Line")
tSrc = input(close, title="Source")
thisEma = ta.ema(tSrc, tLen)
plot(thisEma, title = "Trend Line",color=#ffffff)

MTSection = input(title='══════════ MT LOGIN ══════════', defval=true)
exchange = input.string(defval='MT5', title='EXCHANGE',  options=['MT4', 'MT5'])
mtLogin= input.string(defval="", title='MT LOGIN', group = "mt")
mtPassword =input.string(defval='', title='MT PASSWORD',  group = "mt")
mtServer =input.string(defval='', title='MT SERVER', group = "mt")
mtIsOn = input.string(defval='ON', title='STRATEGY ON', options=['ON', 'OFF'])
mtEntryMode = input.string(defval='CLOSE OPEN', title='ENTRY MODE', options=['CLOSE OPEN', 'OPEN'])

displaySection = input(title='══════════ DISPLAY LOGIN ══════════', defval=true)
displayTable = input(title="DISPLAY TABLE", defval=false, group = 'PRODUCTION', tooltip = "MAKES YOUR STRATEGY TRIGGER SLOWER")



//
// ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒ //

// LOGIC TO FIND DIRECTION WHEN THERE IS TREND CHANGE ACCORDING VOLATILITY
atr = multplierFactor * ta.atr(barsBack)

longStop = hl2 - atr
longStopPrev = nz(longStop[1], longStop)
longStop := close[1] > longStopPrev ? math.max(longStop, longStopPrev) : longStop

shortStop = hl2 + atr
shortStopPrev = nz(shortStop[1], shortStop)
shortStop := close[1] < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop

direction = 1
direction := nz(direction[1], direction)
direction := direction == -1 and close > shortStopPrev ? 1 : direction == 1 and close < longStopPrev ? -1 : direction


longColor = color.blue
shortColor = color.blue

var valueToPlot = 0.0
var colorToPlot = color.white

if direction == 1
    valueToPlot := longStop
    colorToPlot := color.green
    colorToPlot
else
    valueToPlot := shortStop
    colorToPlot := color.red
    colorToPlot

//RSI

src = close

ep = 2 * RSI - 1
auc = ta.ema(math.max(src - src[1], 0), ep)
adc = ta.ema(math.max(src[1] - src, 0), ep)
x1 = (RSI - 1) * (adc * 70 / (100 - 70) - auc)
ub = x1 >= 0 ? src + x1 : src + x1 * (100 - 70) / 70
x2 = (RSI - 1) * (adc * 30 / (100 - 30) - auc)
lb = x2 >= 0 ? src + x2 : src + x2 * (100 - 30) / 30

//Affichage
plot(math.avg(ub, lb), color=color.white ,linewidth=1, title='RSI')
plot(valueToPlot == 0.0 ? na : valueToPlot, title='Action Line', linewidth=2, color=color.new(colorToPlot, 0))
plotshape(direction == 1 and direction[1] == -1 ? longStop : na, title='Buy', style=shape.labelup, location=location.absolute, size=size.normal, text='Buy', textcolor=color.new(color.white, 0), color=color.new(color.green, 0))
plotshape(direction == -1 and direction[1] == 1 ? shortStop : na, title='Sell', style=shape.labeldown, location=location.absolute, size=size.normal, text='Sell', textcolor=color.new(color.white, 0), color=color.new(color.red, 0))



p_ma1 = plot(valueToPlot, title = "ST", color = color.rgb(255, 236, 66))
p_ma2 = plot(math.avg(ub, lb), title = "RSI", color = color.rgb(234, 0, 255))
// Definitions: Trends
TrendUp1() =>
    valueToPlot > math.avg(ub, lb)
TrendDown1() =>
    valueToPlot < math.avg(ub, lb)

trendColor1 = TrendUp1() ? color.rgb(255, 236, 66, 85): TrendDown1() ? color.rgb(234, 0, 255, 85) : color.rgb(255, 255, 255, 85)
fill(p_ma1, p_ma2, color=trendColor1)


longCondition () =>
    ta.crossover(close, valueToPlot)

shortCondition () =>
    ta.crossunder(close, valueToPlot)

IsLongShort() =>
    strategy.position_size != 0

getNewLotSize() => 
    math.abs(riskPer / (close - valueToPlot))

// plot(getNewLotSize(), "new lot size")
newLotS = getNewLotSize()


alertManagement = str.tostring(exchange) + "," + str.tostring(mtLogin) +  "," +str.tostring(mtPassword) + "," 
alertManagement += str.tostring(mtServer) + "," + str.tostring(newLotS)
// alertManagement += str.tostring(stopLoss) + "," + str.tostring(applyingSL) + "," + str.tostring(applyTrailingStop)  + "," 
// alertManagement += str.tostring(exchange) + "," + str.tostring(exchangeAccount) + "," + str.tostring(slAmount)  + "," + str.tostring(closeTpAmount) + "," 
// alertManagement += str.tostring(exchangeLeverage) + "," + str.tostring(exchangeLeverageType) + "," 
// alertManagement += str.tostring(mtLogin) + "," + str.tostring(mtPassword) + "," + str.tostring(mtServer)  + "," + str.tostring(mtLot) + "," 
// alertManagement += str.tostring(mtTp) + "," + str.tostring(mtTs) + "," + str.tostring(orderStrategy) 


// alertManagement = "alertManagement"
myStop = 0.0
myTarget = 0.0

if (longCondition())
    qtyLongTargetPrice := math.abs((RiskSize / ((close - valueToPlot) * syminfo.pointvalue)) / lotSize)
    if IsLongShort()
        strategy.close_all(comment = "close all entries")
    strategy.entry("LONG", strategy.long, qty=12, comment="LONG", alert_message=alertManagement)
    strategy.exit("TPL", "LONG", stop=valueToPlot, limit= close + (close - valueToPlot), comment="Target", alert_message=alertManagement)

if (shortCondition())
    qtyLongTargetPrice := math.abs((RiskSize / ((close - valueToPlot) * syminfo.pointvalue)) / lotSize)
    if IsLongShort()
        strategy.close_all(comment = "close all entries")
    strategy.entry("SHORT", strategy.short, qty=12, comment="SHORT", alert_message=alertManagement)
    strategy.exit("TPS", "SHORT", stop=valueToPlot, limit= close + (close - valueToPlot), comment="Target", alert_message=alertManagement)


// Calculate the average profit per open trade
// avgProfit = profitSum / strategy.opentrades

getTotalProfit()=>
    // Sum the profit of all open trades
    profitSum = 0.0
    for tradeNumber = 0 to strategy.closedtrades - 1
        if strategy.closedtrades.profit(tradeNumber) > 0
            profitSum += strategy.closedtrades.profit(tradeNumber)
    result = profitSum

getTotalLoss()=>
    // Sum the profit of all open trades
    lossSum = 0.0
    for tradeNumber = 0 to strategy.closedtrades - 1
        if strategy.closedtrades.profit(tradeNumber) < 0
            lossSum += strategy.closedtrades.profit(tradeNumber)
    result = lossSum


maxLossRun()=>
    lossRun = 0.0
    currentMaxLoss = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        if strategy.closedtrades.profit(tradeNo) < 0.0
            lossRun += strategy.closedtrades.profit(tradeNo)
        else 
            currentMaxLoss := math.min(currentMaxLoss, lossRun)  
            lossRun := 0.0
    result = currentMaxLoss



TotalTrades() =>
	strategy.closedtrades + strategy.opentrades

maxDrawDown() =>
    maxDrawdown = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        maxDrawdown := math.max(maxDrawdown, strategy.closedtrades.max_drawdown(tradeNo))
    result = maxDrawdown

maxRunUp() =>
    maxRunup = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        maxRunup := math.max(maxRunup, strategy.closedtrades.max_runup(tradeNo))
    result = maxRunup

tradeMaxLossReached() =>
    maxLoss = 0.0
    for tradeNo = 0 to strategy.closedtrades - 1
        maxLoss := math.min(maxLoss, strategy.closedtrades.profit(tradeNo))
    result = maxLoss


tradingStartTime() =>
    strategy.closedtrades.entry_time(0)





daysBetween(t1, t2) => (t1 - t2) / 86400000

// Table
var InfoPanel = table.new(position = position.bottom_right, columns = 2, rows = 40, border_width = 1)
ftable(_table_id, _column, _row, _text, _bgcolor) => 
    table.cell(_table_id, _column, _row, _text, 0, 0, color.black, text.align_right, text.align_center, size.small, _bgcolor)

tfString(int timeInMs) =>
    // @function    Produces a string corresponding to the input time in days, hours, and minutes.
    // @param       (series int) A time value in milliseconds to be converted to a string variable. 
    // @returns     (string) A string variable reflecting the amount of time from the input time.
    float s  = timeInMs / 100000
    float m  = s / 60
    float h  = m / 60
    float d  = h / 24
    float mo = d / 30.416
    int tm   = math.floor(m % 60)
    int tr   = math.floor(h % 24)
    int td   = math.floor(d % 30.416)
    int tmo  = math.floor(mo % 12)
    int ys   = math.floor(d / 365)
    
    string result = 
      switch
        d == 30 and tr == 10 and tm == 30 => "1M"
        d == 7  and tr == 0  and tm == 0  => "1W"
        =>
            string yStr  = ys  ? str.tostring(ys)  + "Y "  : ""
            string moStr = tmo ? str.tostring(tmo) + "M "  : ""
            string dStr  = td  ? str.tostring(td)  + "D "  : ""
            string hStr  = tr  ? str.tostring(tr)  + "H "  : ""
            string mStr  = tm  ? str.tostring(tm)  + "min" : ""
            yStr + moStr + dStr + hStr + mStr


          
if displayTable
    maxLossRunInMarket= maxLossRun()
    maxLossReached = tradeMaxLossReached()
    tradeMaxLossReached = tradeMaxLossReached()
    tradingInDays=daysBetween(time, tradingStartTime())
    totalTrades=TotalTrades()
더 많은

2019 FMZ - 모든 권리 보호