ianzeng123
为什么传统趋势跟踪策略在震荡市中频频”翻车”？
作为一名量化交易从业者，我经常被问到这样一个问题：为什么那些在趋势市场中表现优异的策略，一到震荡行情就开始大幅回撤？
答案其实很简单：大多数趋势跟踪策略都患有”趋势强迫症”——它们总是试图在任何市场环境下都保持高频交易，却忽略了一个基本事实：市场70%的时间都处于横盘震荡状态。
今天要分析的这个”趋势阶梯平均策略”，恰恰针对这个痛点提出了一个有趣的解决方案：在趋势市场中积极跟踪，在震荡市场中”优雅躺平”。
什么是”阶梯平均”？这个概念如何重新定义趋势跟踪？
传统的移动平均线策略有一个致命缺陷：它们总是在变化。无论市场是强势趋势还是横盘震荡，均线都会随着价格波动而不断调整，这就导致了大量的假信号。
而”阶梯平均”的核心思想是：让均线在特定条件下”冻结”。
具体实现逻辑如下：
趋势状态检测：通过ADX指标判断市场趋势强度
- ADX > 25：强趋势市场
- 均线斜率 < 0.3%：横盘市场
动态均线切换：
- 强趋势时：正常跟踪EMA(21)
- 横盘时：均线”冻结”在水平位置，形成支撑/阻力
这种设计的巧妙之处在于：它让策略在不同市场环境下表现出不同的”性格”——趋势时敏感，震荡时稳重。
如何实现”趋势捕捉”系统？
除了基础的阶梯平均机制，该策略还集成了一个”趋势捕捉”模块，这是我认为最具创新性的部分：
快速反转机制： - 当刚刚平仓的反向强趋势出现时 - 在3个周期内快速建立新仓位 - 条件：ADX > 30 且 DI+与DI-差值 > 10
这个设计解决了传统策略的一个重要问题：如何在趋势反转初期快速调整仓位。
想象这样一个场景：你刚刚因为止损平掉了多头仓位，结果市场立即出现强势下跌趋势。传统策略可能需要等待新的信号确认，但这个”趋势捕捉”系统能够在3个周期内快速建立空头仓位。
风险管理：为什么要区分市场状态？
该策略最值得学习的地方是其差异化的风险管理机制：
横盘市场中的风险控制： - 止损位调整至阶梯均线附近 - 降低ATR倍数，收紧止损 - 目标位设置更加保守
趋势市场中的风险控制： - 采用标准ATR倍数止损 - 启用阶梯式移动止损 - 允许更大的价格波动空间
这种设计体现了一个重要的交易哲学：不同的市场环境需要不同的风险偏好。在横盘市场中，我们应该更加谨慎；在趋势市场中，我们需要给利润更多的奔跑空间。
阶梯式移动止损：如何平衡保护利润与趋势跟踪？
传统的移动止损往往过于机械化，要么过紧导致过早离场，要么过松无法有效保护利润。该策略的阶梯式移动止损提供了一个更加智能的解决方案：
阶梯设置逻辑： - 基于ATR动态计算阶梯间距 - 最多设置5个阶梯级别 - 每突破一个阶梯，止损位相应上调
这种设计的优势在于：它能够在保护利润的同时，给趋势足够的发展空间。
实际应用中需要注意什么？
基于我的实盘经验，使用这类策略需要注意以下几点：
参数优化的陷阱：不要过度优化ADX阈值，25-30之间的数值在大多数市场中都表现稳定
市场适应性：该策略更适合波动性适中的市场，在极端波动环境下可能需要调整ATR倍数
资金管理：建议单笔仓位不超过总资金的10%，特别是在启用趋势捕捉功能时
回测陷阱：要特别注意滑点和手续费的影响，特别是在震荡市场中的频繁交易
这个策略的创新价值在哪里？
从量化策略发展的角度来看，这个策略代表了一个重要的进化方向：从单一逻辑向多状态自适应的转变。
传统策略往往试图用一套固定的逻辑应对所有市场情况，而这个策略则展现了”因地制宜”的智慧： - 在趋势市场中表现得像一个激进的趋势跟踪者 - 在震荡市场中表现得像一个保守的区间交易者
这种设计思路对于策略开发者具有重要的启发意义：我们应该让策略具备”市场感知”能力，而不是盲目地执行固定逻辑。
最后，需要强调的是，任何策略都不是万能的。这个阶梯平均策略虽然在理论上很优雅，但在实际应用中仍需要结合具体的市场环境和个人风险偏好进行调整。记住，最好的策略永远是最适合你的策略。
策略源码
/*backtest
start: 2024-10-09 00:00:00
end: 2025-10-07 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"SOL_USDT","balance":500000}]
*/
//@version=5
strategy("Trend Following Ladder Average Strategy", overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=10)
// ═══════════════════════════════════════════════════════════════════════════════
// SETTINGS AND PARAMETERS
// ═══════════════════════════════════════════════════════════════════════════════
// Ladder Average Settings
ma_length = input.int(title="Average Period", defval=21, minval=5)
ma_type = input.string(title="Average Type", defval="EMA", options=["SMA", "EMA", "WMA"])
// Trend Strength Settings
adx_length = input.int(title="Trend Strength Period (ADX)", defval=14, minval=5)
trend_threshold = input.float(title="Trend Strength Threshold", defval=25.0, minval=10.0, step=5.0)
sideways_slope_threshold = input.float(title="Sideways Market Slope Threshold", defval=0.3, minval=0.1, step=0.1)
// Trend Catching Settings
enable_trend_catch = input.bool(title="Trend Catching System", defval=true)
trend_catch_adx_threshold = input.float(title="Trend Catch ADX Threshold", defval=30.0, minval=20.0, step=5.0)
trend_catch_di_diff = input.float(title="DI+ DI- Difference Threshold", defval=10.0, minval=5.0, step=2.5)
quick_entry_bars = input.int(title="Quick Entry Waiting Bars", defval=3, minval=1, maxval=10)
// ATR and Volatility Settings
atr_length = input.int(title="ATR Period", defval=14, minval=1)
atr_multiplier = input.float(title="ATR Multiplier", defval=2.0, minval=0.1, step=0.1)
// Ladder Trailing Stop Settings
ladder_step = input.float(title="Ladder Step Size (%)", defval=1.0, minval=0.1, step=0.1)
max_ladders = input.int(title="Maximum Ladder Count", defval=5, minval=2, maxval=10)
// Stop Loss and Take Profit Settings
use_stop_loss = input.bool(title="Use Stop Loss", defval=false)
use_take_profit = input.bool(title="Use Take Profit", defval=false)
use_trailing_stop = input.bool(title="Use Trailing Stop", defval=true)
sl_type = input.string(title="Stop Loss Type", defval="ATR", options=["ATR", "Percent", "Points"])
sl_atr_multiplier = input.float(title="SL ATR Multiplier", defval=2.0, minval=0.5, step=0.1)
sl_percent = input.float(title="SL Percent (%)", defval=2.0, minval=0.1, step=0.1)
sl_points = input.float(title="SL Points", defval=100, minval=1)
tp_type = input.string(title="Take Profit Type", defval="ATR", options=["ATR", "Percent", "Points", "Risk/Reward"])
tp_atr_multiplier = input.float(title="TP ATR Multiplier", defval=3.0, minval=0.5, step=0.1)
tp_percent = input.float(title="TP Percent (%)", defval=3.0, minval=0.1, step=0.1)
tp_points = input.float(title="TP Points", defval=150, minval=1)
tp_risk_reward = input.float(title="Risk/Reward Ratio", defval=2.0, minval=0.5, step=0.1)
// Horizontal Level Settings
horizontal_lookback = input.int(title="Horizontal Level Stabilization Period", defval=10, minval=3)
// ═══════════════════════════════════════════════════════════════════════════════
// INDICATORS AND CALCULATIONS
// ═══════════════════════════════════════════════════════════════════════════════
// ATR calculation
atr_value = ta.atr(atr_length)
// Moving Average calculation
ma_value = ma_type == "SMA" ? ta.sma(close, ma_length) : ma_type == "EMA" ? ta.ema(close, ma_length) : ma_type == "WMA" ? ta.wma(close, ma_length) : ta.ema(close, ma_length)
// ADX (Trend Strength) calculation - Manual calculation
tr = math.max(high - low, math.max(math.abs(high - close[1]), math.abs(low - close[1])))
plus_dm = high - high[1] > low[1] - low ? math.max(high - high[1], 0) : 0
minus_dm = low[1] - low > high - high[1] ? math.max(low[1] - low, 0) : 0
plus_di = 100 * ta.rma(plus_dm, adx_length) / ta.rma(tr, adx_length)
minus_di = 100 * ta.rma(minus_dm, adx_length) / ta.rma(tr, adx_length)
adx_value = 100 * ta.rma(math.abs(plus_di - minus_di) / (plus_di + minus_di), adx_length)
// MA slope calculation (for sideways market detection)
ma_slope = (ma_value - ma_value[5]) / ma_value[5] * 100
// Trend state detection
is_strong_trend = adx_value > trend_threshold
is_sideways_by_slope = math.abs(ma_slope) < sideways_slope_threshold
is_sideways = not is_strong_trend or is_sideways_by_slope
// Trend direction detection (DI+ vs DI-)
is_uptrend = plus_di > minus_di
is_downtrend = minus_di > plus_di
di_difference = math.abs(plus_di - minus_di)
// Strong trend momentum detection
strong_uptrend = adx_value > trend_catch_adx_threshold and plus_di > minus_di and di_difference > trend_catch_di_diff
strong_downtrend = adx_value > trend_catch_adx_threshold and minus_di > plus_di and di_difference > trend_catch_di_diff
// Position tracking system
var bool just_closed_long = false
var bool just_closed_short = false
var int bars_since_close = 0
// Position closure tracking - Fixed
if strategy.position_size == 0 and strategy.position_size[1] != 0
if strategy.position_size[1] > 0
just_closed_long := true
just_closed_short := false
else
just_closed_short := true
just_closed_long := false
bars_since_close := 0
else if strategy.position_size == 0
bars_since_close += 1
if bars_since_close > quick_entry_bars
just_closed_long := false
just_closed_short := false
else
just_closed_long := false
just_closed_short := false
bars_since_close := 0
// Ladder Average System
var float ladder_ma = na
var float horizontal_level = na
var int sideways_count = 0
// Trend-following ladder average
if is_strong_trend and not is_sideways_by_slope
// Normal MA tracking in strong trend
ladder_ma := ma_value
sideways_count := 0
else
// When trend weakens or in sideways market
sideways_count += 1
if sideways_count >= horizontal_lookback or na(horizontal_level)
horizontal_level := ma_value
ladder_ma := horizontal_level
// Market state
market_state = is_strong_trend and not is_sideways_by_slope ? "TREND" : "SIDEWAYS"
// Volatility measurement
volatility = atr_value / close * 100
// ═══════════════════════════════════════════════════════════════════════════════
// STOP LOSS AND TAKE PROFIT CALCULATIONS
// ═══════════════════════════════════════════════════════════════════════════════
// Stop Loss calculation function
calculate_stop_loss(entry_price_val, is_long) =>
sl_value = sl_type == "ATR" ? (is_long ? entry_price_val - (atr_value * sl_atr_multiplier) : entry_price_val + (atr_value * sl_atr_multiplier)) : sl_type == "Percent" ? (is_long ? entry_price_val * (1 - sl_percent / 100) : entry_price_val * (1 + sl_percent / 100)) : sl_type == "Points" ? (is_long ? entry_price_val - sl_points : entry_price_val + sl_points) : (is_long ? entry_price_val - (atr_value * sl_atr_multiplier) : entry_price_val + (atr_value * sl_atr_multiplier))
sl_adjusted = if is_sideways
is_long ? math.min(sl_value, ladder_ma - atr_value * 0.5) : math.max(sl_value, ladder_ma + atr_value * 0.5)
else
sl_value
sl_adjusted
// Take Profit calculation function
calculate_take_profit(entry_price_val, stop_loss_val, is_long) =>
tp_value = tp_type == "ATR" ? (is_long ? entry_price_val + (atr_value * tp_atr_multiplier) : entry_price_val - (atr_value * tp_atr_multiplier)) : tp_type == "Percent" ? (is_long ? entry_price_val * (1 + tp_percent / 100) : entry_price_val * (1 - tp_percent / 100)) : tp_type == "Points" ? (is_long ? entry_price_val + tp_points : entry_price_val - tp_points) : tp_type == "Risk/Reward" ? (is_long ? entry_price_val + (math.abs(entry_price_val - stop_loss_val) * tp_risk_reward) : entry_price_val - (math.abs(entry_price_val - stop_loss_val) * tp_risk_reward)) : (is_long ? entry_price_val + (atr_value * tp_atr_multiplier) : entry_price_val - (atr_value * tp_atr_multiplier))
tp_adjusted = if is_sideways
is_long ? math.max(tp_value, ladder_ma + atr_value * 1.5) : math.min(tp_value, ladder_ma - atr_value * 1.5)
else
tp_value
tp_adjusted
var float current_sl = na
var float current_tp = na
// ═══════════════════════════════════════════════════════════════════════════════
// ENTRY SIGNALS
// ═══════════════════════════════════════════════════════════════════════════════
// Normal entry conditions
normal_long = strategy.position_size == 0 and ((is_strong_trend and close > ladder_ma and close[1] <= ladder_ma[1]) or (is_sideways and close < ladder_ma and close > ladder_ma - atr_value))
normal_short = strategy.position_size == 0 and ((is_strong_trend and close < ladder_ma and close[1] >= ladder_ma[1]) or (is_sideways and close > ladder_ma and close < ladder_ma + atr_value))
// Trend catching entry conditions
trend_catch_long = enable_trend_catch and strategy.position_size == 0 and just_closed_short and bars_since_close <= quick_entry_bars and strong_uptrend and close > close[1] and close > ladder_ma
trend_catch_short = enable_trend_catch and strategy.position_size == 0 and just_closed_long and bars_since_close <= quick_entry_bars and strong_downtrend and close < close[1] and close < ladder_ma
// Strong momentum entry conditions (even if no position closed, but strong trend exists)
momentum_long = enable_trend_catch and strategy.position_size == 0 and strong_uptrend and close > ladder_ma and close > close[1] and close > open
momentum_short = enable_trend_catch and strategy.position_size == 0 and strong_downtrend and close < ladder_ma and close < close[1] and close < open
// Combined entry conditions
long_condition = normal_long or trend_catch_long or momentum_long
short_condition = normal_short or trend_catch_short or momentum_short
// Entry type determination
entry_type = if trend_catch_long or trend_catch_short
"TREND_CATCH"
else if momentum_long or momentum_short
"MOMENTUM"
else
market_state
// ═══════════════════════════════════════════════════════════════════════════════
// LADDER TRAILING STOP SYSTEM
// ═══════════════════════════════════════════════════════════════════════════════
var float[] ladder_levels = array.new<float>()
var float current_trailing_stop = na
var float entry_price = na
// Calculate ladder levels function
calculate_ladder_levels(entry_price_val, is_long) =>
ladder_array = array.new<float>()
base_level = ladder_ma
for i = 1 to max_ladders
level_value = if is_long
base_level + (atr_value * atr_multiplier * i * ladder_step / 100)
else
base_level - (atr_value * atr_multiplier * i * ladder_step / 100)
array.push(ladder_array, level_value)
ladder_array
// Trailing stop update function
update_trailing_stop(entry_price_val, current_price, is_long) =>
stop_level = if is_long
initial_stop = is_sideways ? ladder_ma - atr_value : entry_price_val - (atr_value * atr_multiplier)
new_stop = initial_stop
if array.size(ladder_levels) > 0
for i = 0 to array.size(ladder_levels) - 1
level_value = array.get(ladder_levels, i)
if current_price >= level_value
adjusted_stop = is_sideways ? ladder_ma : entry_price_val + (atr_value * atr_multiplier * (i + 1) * 0.3)
if adjusted_stop > new_stop
new_stop := adjusted_stop
new_stop
else
initial_stop = is_sideways ? ladder_ma + atr_value : entry_price_val + (atr_value * atr_multiplier)
new_stop = initial_stop
if array.size(ladder_levels) > 0
for i = 0 to array.size(ladder_levels) - 1
level_value = array.get(ladder_levels, i)
if current_price <= level_value
adjusted_stop = is_sideways ? ladder_ma : entry_price_val - (atr_value * atr_multiplier * (i + 1) * 0.3)
if adjusted_stop < new_stop
new_stop := adjusted_stop
new_stop
stop_level
// ═══════════════════════════════════════════════════════════════════════════════
// POSITION MANAGEMENT
// ═══════════════════════════════════════════════════════════════════════════════
// Long position entry
if long_condition
strategy.entry("Long", strategy.long, comment="Long: " + market_state)
entry_price := close
ladder_levels := calculate_ladder_levels(close, true)
// Stop Loss calculation (only if active)
if use_stop_loss
current_sl := calculate_stop_loss(close, true)
// Take Profit calculation (only if active)
if use_take_profit
temp_sl = use_stop_loss ? current_sl : close - (atr_value * sl_atr_multiplier)
current_tp := calculate_take_profit(close, temp_sl, true)
// Trailing stop initialization (only if active)
if use_trailing_stop
current_trailing_stop := is_sideways ? ladder_ma - atr_value : close - (atr_value * atr_multiplier)
// Short position entry
if short_condition
strategy.entry("Short", strategy.short, comment="Short: " + market_state)
entry_price := close
ladder_levels := calculate_ladder_levels(close, false)
// Stop Loss calculation (only if active)
if use_stop_loss
current_sl := calculate_stop_loss(close, false)
// Take Profit calculation (only if active)
if use_take_profit
temp_sl = use_stop_loss ? current_sl : close + (atr_value * sl_atr_multiplier)
current_tp := calculate_take_profit(close, temp_sl, false)
// Trailing stop initialization (only if active)
if use_trailing_stop
current_trailing_stop := is_sideways ? ladder_ma + atr_value : close + (atr_value * atr_multiplier)
// Position exit management
if strategy.position_size > 0 // Long position
// If using fixed SL/TP
if use_stop_loss and use_take_profit
strategy.exit("Long Exit", "Long", stop=current_sl, limit=current_tp, comment="SL/TP")
else if use_stop_loss and not use_take_profit
strategy.exit("Long Exit", "Long", stop=current_sl, comment="SL Only")
else if not use_stop_loss and use_take_profit
strategy.exit("Long Exit", "Long", limit=current_tp, comment="TP Only")
// If using trailing stop (optional)
if use_trailing_stop
current_trailing_stop := update_trailing_stop(entry_price, close, true)
if close <= current_trailing_stop
strategy.close("Long", comment="Trailing Stop")
if strategy.position_size < 0 // Short position
// If using fixed SL/TP
if use_stop_loss and use_take_profit
strategy.exit("Short Exit", "Short", stop=current_sl, limit=current_tp, comment="SL/TP")
else if use_stop_loss and not use_take_profit
strategy.exit("Short Exit", "Short", stop=current_sl, comment="SL Only")
else if not use_stop_loss and use_take_profit
strategy.exit("Short Exit", "Short", limit=current_tp, comment="TP Only")
// If using trailing stop (optional)
if use_trailing_stop
current_trailing_stop := update_trailing_stop(entry_price, close, false)
if close >= current_trailing_stop
strategy.close("Short", comment="Trailing Stop")
// ═══════════════════════════════════════════════════════════════════════════════
// VISUALIZATION
// ═══════════════════════════════════════════════════════════════════════════════
// Ladder Average plot
plot(ladder_ma, color=is_sideways ? color.orange : (ma_slope > 0 ? color.green : color.red), linewidth=3, title="Ladder Average")
// Horizontal level plot
plot(is_sideways ? horizontal_level : na, color=color.yellow, style=plot.style_circles, linewidth=2, title="Horizontal Level")
// ATR-based bands
upper_band = ladder_ma + atr_value
lower_band = ladder_ma - atr_value
plot(upper_band, color=color.new(color.blue, 70), title="Upper ATR Band")
plot(lower_band, color=color.new(color.blue, 70), title="Lower ATR Band")
// Stop Loss and Take Profit plots (only if active)
plot(strategy.position_size != 0 and use_stop_loss ? current_sl : na, color=color.red, style=plot.style_circles, linewidth=2, title="Stop Loss")
plot(strategy.position_size != 0 and use_take_profit ? current_tp : na, color=color.green, style=plot.style_circles, linewidth=2, title="Take Profit")
// Trailing stop plot (only if active)
plot(strategy.position_size > 0 and use_trailing_stop ? current_trailing_stop : na, color=color.orange, style=plot.style_stepline, linewidth=2, title="Long Trailing Stop")
plot(strategy.position_size < 0 and use_trailing_stop ? current_trailing_stop : na, color=color.orange, style=plot.style_stepline, linewidth=2, title="Short Trailing Stop")
// Market state background color
bgcolor(is_sideways ? color.new(color.yellow, 95) : (is_strong_trend ? color.new(color.green, 98) : color.new(color.gray, 98)), title="Market State")
相关推荐