다채널 동적 지원 저항 켈트너 채널 전략
저자:차오장, 날짜: 2025-01-17 15:17:59태그:KCEMAATRSMAWMAPPSR
전반적인 설명
이 전략은 켈트너 채널과 동적 지지/저항 수준을 기반으로 한 포괄적인 거래 시스템이다. 이동 평균과 변동성 지표를 결합하여 완전한 거래 의사 결정 프레임워크를 형성하여 여러 시간 프레임을 분석합니다. 핵심 접근법은 높은 확률의 거래 기회를 포착하기 위해 시장 추세와 변동성을 고려하면서 가격 브레이크 기회를 식별하는 것입니다.
전략 원칙
이 전략은 여러 계층의 기술 지표 시스템을 사용합니다. 1. 주요 트렌드 식별 도구로 21 기간 켈트너 채널을 사용하며 채널 너비는 ATR에 의해 결정됩니다. 2. 21 왼쪽 및 8 오른쪽 바를 사용하여 주요 지원 / 저항 수준을 계산 3. 트렌드 필터로 더 높은 시간 프레임 이동 평균을 포함합니다. 4. 엔트리 시기를 위해 단기 (5주기) 및 장기 (30주기) 이동 평균을 결합합니다. 5. 동적 스톱 로스 조절을 위해 ATR를 사용합니다.
전략적 장점
- 다차원 기술 지표는 서로 확인하여 잘못된 신호를 줄여줍니다.
- 시장 변화에 적응하여 실시간으로 동적 지지/저항 레벨 업데이트
- 더 높은 시간 프레임 분석은 2차 시장 움직임을 필터
- 다른 시간 프레임에 기반한 유연한 스톱 로스 매개 변수
- 효율적인 위험 통제를 위한 비율 기반의 포지션 관리
전략 위험
- 다양한 시장에서 빈번한 거래 신호를 생성 할 수 있습니다.
- 다중 지표 검증은 일부 거래 기회를 놓칠 수 있습니다.
- 매개 변수 최적화는 과도한 부착 위험을 야기합니다.
- 높은 변동성 환경에서는 스톱 로스 레벨이 너무 넓을 수 있습니다.
- 급격한 시장 변화 시 지원/저항 수준이 실패할 수 있습니다.
최적화 방향
- 부진을 검증하기 위해 부피 지표를 포함합니다.
- 동적 매개 변수 조정을 위한 시장 변동성 분석 모듈 추가
- 더 나은 정확성을 위해 지원/ 저항 계산 방법을 개선
- 진입 조건을 정비하기 위해 트렌드 강도 평가를 추가합니다.
- 보다 정확한 위험 통제를 위해 포지션 관리 시스템을 개선
요약
이 전략은 잘 구성되어 있고 논리적으로 엄격한 양적 거래 전략이다. 여러 기술적 지표의 조율된 사용을 통해 신뢰할 수 있는 거래 신호와 효과적인 위험 통제를 모두 보장한다. 전략의 강력한 확장성은 지속적인 최적화와 개선을 가능하게 하며, 잠재적으로 다른 시장 환경에서 안정적인 성능을 유지할 수 있다.
/*backtest
start: 2024-12-17 00:00:00
end: 2024-12-21 00:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT","balance":49999}]
*/
// This Pine Script™ code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © sathcm
//@version=5
strategy("KMS", overlay=true, initial_capital=100000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.05, slippage=3)
// Inputs for Keltner Channels
kcLength = input.int(21, title="Keltner Channel Length", minval=1) // Length for Keltner Channel calculation
kcMultiplier = input.float(2.0, title="Keltner Channel Multiplier", minval=0.1) // Multiplier for Keltner Channel width
// Calculate Keltner Channels using best practices
kcBasis = ta.ema(close, kcLength) // Use EMA for a smoother basis line
atrValue = ta.atr(kcLength) // Use ATR for channel width calculation
kcUpper = kcBasis + kcMultiplier * atrValue // Upper Keltner Channel
kcLower = kcBasis - kcMultiplier * atrValue // Lower Keltner Channel
// Inputs for Pivot Point Calculation
leftBars = input.int(21, title="Left Bars", minval=1) // Number of bars to the left for pivot calculation
rightBars = input.int(8, title="Right Bars", minval=1, tooltip="Number of bars to the right for pivot calculation") // Number of bars to the right for pivot calculation
// Calculate Smoothed Pivot Highs and Lows using Weighted Moving Average
pivotHigh = ta.pivothigh(high, leftBars, rightBars) // Apply WMA for smoothing
pivotLow = ta.pivotlow(low, leftBars, rightBars) // Apply WMA for smoothing
// Convert Pivot Highs and Lows to Boolean Conditions
isPivotHigh = not na(pivotHigh) // True when a pivot high exists
isPivotLow = not na(pivotLow) // True when a pivot low exists
// Get Recent Support and Resistance Levels
recentResistance = ta.valuewhen(isPivotHigh, high, 0) // Most recent resistance level
recentSupport = ta.valuewhen(isPivotLow, low, 0) // Most recent support level
// Plot Smoothed Support and Resistance Levels
//plot(recentResistance, color=color.red, title="Recent Resistance", linewidth=2, style=plot.style_line)
//plot(recentSupport, color=color.green, title="Recent Support", linewidth=2, style=plot.style_line)
// Store Entry Price into a Variable
var float entryPrice = na // Declare a variable to store the entry price
// Input for Higher Timeframe
higherTimeframeInput = input.timeframe('W', title="Higher Timeframe for MA Calculation")
if (timeframe.period == "240") or (timeframe.period == "120")
higherTimeframeInput := "D"
if (timeframe.period == "60") or (timeframe.period == "30") or (timeframe.period == "15")
higherTimeframeInput := "120"
if (timeframe.period == "10") or (timeframe.period == "5")
higherTimeframeInput := "30"
if (timeframe.period == "1")
higherTimeframeInput := "10"
prd = input.int(defval=10, title='Pivot Period', minval=4, maxval=30, group='Settings 🔨', tooltip='Used while calculating Pivot Points, checks left&right bars')
ppsrc = input.string(defval='High/Low', title='Source', options=['High/Low', 'Close/Open'], group='Settings 🔨', tooltip='Source for Pivot Points')
ChannelW = input.int(defval=5, title='Maximum Channel Width %', minval=1, maxval=8, group='Settings 🔨', tooltip='Calculated using Highest/Lowest levels in 300 bars')
minstrength = input.int(defval=1, title='Minimum Strength', minval=1, group='Settings 🔨', tooltip='Channel must contain at least 2 Pivot Points')
maxnumsr = input.int(defval=4, title='Maximum Number of S/R', minval=1, maxval=10, group='Settings 🔨', tooltip='Maximum number of Support/Resistance Channels to Show') - 1
loopback = input.int(defval=150, title='Loopback Period', minval=100, maxval=400, group='Settings 🔨', tooltip='While calculating S/R levels it checks Pivots in Loopback Period')
res_col = input.color(defval=color.new(color.red, 75), title='Resistance Color', group='Colors 🟡🟢🟣')
sup_col = input.color(defval=color.new(color.lime, 75), title='Support Color', group='Colors 🟡🟢🟣')
inch_col = input.color(defval=color.new(color.gray, 75), title='Color When Price in Channel', group='Colors 🟡🟢🟣')
// Get Pivot High/Low
src1 = ppsrc == 'High/Low' ? high : math.max(close, open)
src2 = ppsrc == 'High/Low' ? low : math.min(close, open)
ph = ta.pivothigh(src1, prd, prd)
pl = ta.pivotlow(src2, prd, prd)
// Calculate maximum S/R channel width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * ChannelW / 100
// Get/keep Pivot levels
var pivotvals = array.new_float(0)
var pivotlocs = array.new_float(0)
if ph or pl
array.unshift(pivotvals, ph ? ph : pl)
array.unshift(pivotlocs, bar_index)
for x = array.size(pivotvals) - 1 to 0 by 1
if bar_index - array.get(pivotlocs, x) > loopback // remove old pivot points
array.pop(pivotvals)
array.pop(pivotlocs)
continue
break
// Find/create SR channel of a pivot point
get_sr_vals(ind) =>
float lo = array.get(pivotvals, ind)
float hi = lo
int numpp = 0
for y = 0 to array.size(pivotvals) - 1 by 1
float cpp = array.get(pivotvals, y)
float wdth = cpp <= hi ? hi - cpp : cpp - lo
if wdth <= cwidth // fits the max channel width?
if cpp <= hi
lo := math.min(lo, cpp)
else
hi := math.max(hi, cpp)
numpp += 20 // each pivot point added as 20
[hi, lo, numpp]
// Keep old SR channels and calculate/sort new channels if we met new pivot point
var suportresistance = array.new_float(20, 0) // min/max levels
changeit(x, y) =>
tmp = array.get(suportresistance, y * 2)
array.set(suportresistance, y * 2, array.get(suportresistance, x * 2))
array.set(suportresistance, x * 2, tmp)
tmp := array.get(suportresistance, y * 2 + 1)
array.set(suportresistance, y * 2 + 1, array.get(suportresistance, x * 2 + 1))
array.set(suportresistance, x * 2 + 1, tmp)
if ph or pl
supres = array.new_float(0) // number of pivot, strength, min/max levels
stren = array.new_float(10, 0)
// Get levels and strengths
for x = 0 to array.size(pivotvals) - 1 by 1
[hi, lo, strength] = get_sr_vals(x)
array.push(supres, strength)
array.push(supres, hi)
array.push(supres, lo)
// Add each HL to strength
for x = 0 to array.size(pivotvals) - 1 by 1
h = array.get(supres, x * 3 + 1)
l = array.get(supres, x * 3 + 2)
s = 0
for y = 0 to loopback by 1
if high[y] <= h and high[y] >= l or low[y] <= h and low[y] >= l
s += 1
array.set(supres, x * 3, array.get(supres, x * 3) + s)
// Reset SR levels
array.fill(suportresistance, 0)
// Get strongest SRs
src = 0
for x = 0 to array.size(pivotvals) - 1 by 1
stv = -1. // value
stl = -1 // location
for y = 0 to array.size(pivotvals) - 1 by 1
if array.get(supres, y * 3) > stv and array.get(supres, y * 3) >= minstrength * 20
stv := array.get(supres, y * 3)
stl := y
if stl >= 0
// Get SR level
hh = array.get(supres, stl * 3 + 1)
ll = array.get(supres, stl * 3 + 2)
array.set(suportresistance, src * 2, hh)
array.set(suportresistance, src * 2 + 1, ll)
array.set(stren, src, array.get(supres, stl * 3))
// Make included pivot points' strength zero
for y = 0 to array.size(pivotvals) - 1 by 1
if array.get(supres, y * 3 + 1) <= hh and array.get(supres, y * 3 + 1) >= ll or array.get(supres, y * 3 + 2) <= hh and array.get(supres, y * 3 + 2) >= ll
array.set(supres, y * 3, -1)
src += 1
if src >= 10
break
for x = 0 to 8 by 1
for y = x + 1 to 9 by 1
if array.get(stren, y) > array.get(stren, x)
tmp = array.get(stren, y)
array.set(stren, y, array.get(stren, x))
changeit(x, y)
get_level(ind) =>
float ret = na
if ind < array.size(suportresistance)
if array.get(suportresistance, ind) != 0
ret := array.get(suportresistance, ind)
ret
get_color(ind) =>
color ret = na
if ind < array.size(suportresistance)
if array.get(suportresistance, ind) != 0
ret := array.get(suportresistance, ind) > close and array.get(suportresistance, ind + 1) > close ? res_col : array.get(suportresistance, ind) < close and array.get(suportresistance, ind + 1) < close ? sup_col : inch_col
ret
// var srchannels = array.new_box(10)
// for x = 0 to math.min(9, maxnumsr) by 1
// box.delete(array.get(srchannels, x))
// srcol = get_color(x * 2)
// if not na(srcol)
// array.set(srchannels, x, box.new(left=bar_index, top=get_level(x * 2), right=bar_index + 1, bottom=get_level(x * 2 + 1), border_color=srcol, border_width=1, extend=extend.both, bgcolor=srcol))
// Improved dynamic support detection
float recentSupport1 = na
float previousSupport = na
float currentsupport = na
if na(previousSupport) or currentsupport != previousSupport
if array.size(suportresistance) > 1
for i = 0 to math.floor(array.size(suportresistance) / 2) - 1 // Iterate through support levels
currentsupport := array.get(suportresistance, i * 2 + 1) // Support is stored at odd indices
if currentsupport < close and (na(recentSupport1) or math.abs(close - currentsupport) < math.abs(close - recentSupport1))
previousSupport := currentsupport // Store the newly detected support
// Set the most recent support to the new support
recentSupport1 := na(recentSupport1) ? ta.lowest(low, 10) : currentsupport
// Moving averages for entry and exit
maShort = ta.sma(close, 5)
maLong = ta.sma(close, 30) + ta.atr(14)
// Track entry price
entryPrice1 = strategy.position_avg_price // Get the price of the currently open position
currentTimeFrame = timeframe.period
exitPrice = entryPrice1 * 0.99
if currentTimeFrame == "1H" or currentTimeFrame == "30" or currentTimeFrame == "15" or currentTimeFrame == "5"
exitPrice := entryPrice1 * 0.99 // Set the exit price at 99% of the entry price
if currentTimeFrame == "120" or currentTimeFrame == "180" or currentTimeFrame == "240" or currentTimeFrame == "D"
exitPrice := entryPrice1 * 0.98 // Set the exit price at 95% of the entry price
// Calculate Moving Average based on higher timeframe for length of 20 bars
higherTimeframeMA = request.security(syminfo.tickerid, higherTimeframeInput, ta.sma(close, 20), barmerge.gaps_off, barmerge.lookahead_on) // Calculate MA with adjusted timeframe
// Entry and Exit Conditions for Long
entryLong = (close > kcUpper) and (close > recentResistance) and (close > higherTimeframeMA) // Long entry when price breaks above KC upper, recent resistance, and higher timeframe MA
exitLong = (close < recentResistance - 1.5*atrValue) // Long exit when price falls below recent resistance with cushion of one ATR
// Entry and Exit Conditions for Short
entryShort = (close < kcLower) and (close < recentSupport) and (close < higherTimeframeMA+atrValue) // Add RSI filter to reduce false signals by confirming momentum // Short entry when price breaks below KC lower, recent support, and higher timeframe MA
exitShort = (close > recentSupport + atrValue) // Short exit when price rises above recent support with cushion of one ATR(close > recentSupport + atrValue) // Short exit when price rises above recent support with cushion of one ATR(close > recentSupport + atrValue) // Short exit when price rises above recent support with cushion of one ATR
// Strategy Execution for Long
if not na(recentSupport1) and (close <= recentSupport1 +(close*0.01) or close >= recentSupport1 - (close*0.0075)) and (maShort > maLong) and entryLong
strategy.entry("Long Entry", strategy.long)
//entryPrice := strategy.position_avg_price // Store the entry price when a position is opened
if ((maShort < maLong + 3*ta.atr(14)) or close < exitPrice) and exitLong
strategy.close("Long Entry")
// Strategy Execution for Short
if entryShort
strategy.entry("Short Entry", strategy.short)
entryPrice := strategy.position_avg_price // Store the entry price when a position is opened
if exitShort
strategy.close("Short Entry")
// Plot Keltner Channels
plot(kcUpper, color=color.orange, title="Keltner Channel Upper", linewidth=1)
plot(kcLower, color=color.orange, title="Keltner Channel Lower", linewidth=1)
// Plot Moving Averages
plot(higherTimeframeMA, color=color.blue, title="Higher Timeframe MA", linewidth=2)
//plot(recentSupport1, color=#04313f, title="Recent Support1")
//plot(recentResistance, color=color.purple, title="Recent Resistance")
//plot(entryPrice1, color=color.lime, title="Entry Price 1")
//plot(exitPrice, color=color.maroon, title="Exit Price")
//plot(maShort, color=color.green, title="MA Short")
//plot(maLong, color=color.blue, title="MA Long Plus ATR")
// Highlight Entry Zones
bgcolor(entryLong ? color.new(color.green, 85) : na, title="Long Entry Zone")
bgcolor(entryShort ? color.new(color.red, 85) : na, title="Short Entry Zone")
// Alerts
alertcondition(entryLong, title="Long Entry", message="Price broke above the Keltner Channel and recent resistance for Long Entry")
alertcondition(exitLong, title="Long Exit", message="Price fell below recent resistance with cushion of one ATR - Long Exit")
alertcondition(entryShort, title="Short Entry", message="Price broke below the Keltner Channel and recent support for Short Entry")
alertcondition(exitShort, title="Short Exit", message="Price rose above recent support with cushion of one ATR - Short Exit")
관련
- 다중 시간 프레임 EMA 트렌드 모멘텀 거래 전략
- 슈퍼 점프 턴 백 볼링거 밴드
- ESSMA
- 슈퍼 스칼퍼
- EMA와 SMA를 기반으로 하는 전략에 따른 다중 지표 동적 경향
- 슈퍼 스칼퍼 - 5분 15분
- 슈퍼트렌드 이동 평균
- 다층 변동성 대역 거래 전략
- 이윤 극대화 PMax
- 다중 지표 시너지 트렌드 역전 양적 거래 전략
더 많은
- 이중 크로스오버 트렌드 다음 전략: EMA와 MACD 시너지 거래 시스템
- 내일 패턴 인식과 함께 SMA 기반의 지능형 트레일링 스톱 전략
- 적응형 다중 전략 동적 전환 시스템: 트렌드 추종 및 범위 오스실레이션을 결합하는 양적 거래 전략
- 고급 다중 지표 다차원 트렌드 크로스 양적 전략
- 다중 요인 회귀 및 동적 가격 대역량 거래 시스템
- 다중 지표 동적 트렌드 탐지 및 위험 관리 거래 전략
- 다중 평형 이동 평균 동적 크로스오버 트렌드
- 큰 촛불과 RSI 분리를 기반으로 한 고급 동적 스톱 로스 전략
- 유동성 가중화 이동 평균 모멘텀 크로스오버 전략
- 다중 지표 시너지 트렌드 역전 양적 거래 전략
- 기계 학습 적응성 슈퍼 트렌드 양적 거래 전략
- 동적 물결 트렌드 및 피보나치 통합 양적 거래 전략
- 거래 전략에 따른 변동성 중지 기반 EMA 트렌드
- 동적 변동성 필터와 함께 멀티 EMA 트렌드 다음 전략
- 다중 지표 양적 거래 전략에 따른 트리플 EMA 트렌드
- 연말 트렌드 모멘텀 트레이딩 전략에 따라 ((60일 MA 브레이크)
- 다중 지표 트렌드 RSI 과잉 구매/ 과잉 판매 양적 거래 전략
- 효율적인 가격 채널 거래 전략
- 역사적인 뒷검사를 가진 다중 시간 프레임 공정 가치 격차 분출 전략
- QQE 동적 트렌드 위험 관리 양적 거래 전략