Mesin penangkap tren multidimensi
ianzeng123
EMA, ATR, MOMENTUM, EFFICIENCY, BREAKOUT
Ini bukan strategi garis tengah biasa, ini adalah mesin penangkapan tren multidimensi.
Jangan tertipu oleh pengaturan garis rata-rata tiga 18/50/120 di permukaan. Inti dari strategi ini adalah sistem verifikasi tren dari 8 dimensi independen, yang masing-masing memiliki standar numerik yang jelas.
Masalah dengan strategi rata-rata tradisional adalah terlalu banyak sinyal palsu, sistem ini meningkatkan tingkat keberhasilan masuk ke tingkat yang baru dengan banyak penyaringan seperti efisiensi jalur ((minimal 33%), kontinuitas momentum ((perbandingan garis K naik lebih dari 57%), dan status fluktuasi ((perbandingan ATR lebih dari 95%)).
Deteksi Kualitas Terobosan: 0.15 kali ATR dianggap benar-benar terobosan
Strategi ini menetapkan bahwa kekuatan breakout harus mencapai 0,15 kali ATR, yang berarti bahwa amplitudo breakout harus melebihi 15% dari rata-rata pergerakan terkini untuk dianggap sebagai sinyal yang valid.
Mekanisme penarikan balik yang lebih halus: Memerintahkan harga untuk melakukan penarikan balik yang mendalam setidaknya 0,9 kali ATR dari garis cepat, dan kemudian mencapai intensitas 0,15 kali ATR ketika kembali ke garis rata-rata. Desain ini secara efektif menyaring terobosan palsu yang dangkal dan hanya menangkap yang benar-benar didanai.
2x Leverage + 2.8x ATR Pelacakan Stop Loss Logika Kontrol Risiko
Leverage setup 2x tampak agresif, tetapi dengan 2% hard stop loss dan 2.8x ATR tracking, risiko sebenarnya dapat dikendalikan. Yang lebih penting adalah mekanisme penguncian keuntungan 20.8x ATR, yang secara otomatis meningkatkan stop loss ketika float mencapai tingkat ini, memastikan bahwa keuntungan dalam tren besar tidak akan kembali.
Desain untuk memaksa 1 jalur K yang lengkap untuk menahan menahan frekuensi tinggi dan 5 jalur K untuk menghindari periode pendinginan untuk menghindari transaksi beruntun emosional. Kontrol ritme ini lebih penting daripada indikator teknis murni.
Tiga model masuk mencakup kondisi pasar yang berbeda
Tren melanjutkan masuk: berlaku untuk tren kuat yang telah ditetapkan, menuntut penembusan + kemiringan + efisiensi + momentum semua memenuhi standar. Re-adjustment kembali masuk: untuk tren yang sehat, menuntut kedalaman yang cukup dan merebut kembali kekuatan.
Keunggulan dari desain multi-modal ini adalah tidak melewatkan peluang tren apa pun, dan setiap mode memiliki standar kualitas yang ketat. Bukan jaring yang luas, tetapi sniper presisi.
Indikator Efisiensi adalah salah satu alat penilaian kualitas tren yang paling diremehkan
Efisiensi jalur menghitung rasio perpindahan bersih terhadap perpindahan akumulasi selama 18 siklus, dengan tren yang kurang dari 33% tidak bertepatan. Indikator ini dapat secara efektif mengidentifikasi tren palsu dalam situasi yang bergolak, dan menghindari penghentian berulang di pasar horizontal.
Keterusan momentum membutuhkan lebih dari 57% dari garis K yang berlawanan, dan 12 siklus momentum harus positif. Verifikasi ganda ini memastikan kekuatan intrinsik dari tren, bukan hanya penembusan permukaan harga.
Analisis Kelayakan: Bukan Strategi Sempurna, Tetapi Berhasil di Pasar Tren
Strategi ini jelas memihak pasar tren dan sering memicu sinyal keluar di pasar yang bergolak. Desain untuk memaksa keluar ketika ATR berada di bawah 80% dan efisiensi di bawah 25%, menunjukkan bahwa strategi ini memiliki persyaratan yang jelas untuk lingkungan pasar.
Risiko terbesar adalah keterlambatan periode konversi tren, meskipun ada peringatan awal seperti EMA yang cepat, namun masih mungkin menghadapi penarikan besar dalam pembalikan cepat. Disarankan untuk digunakan pada pertumbuhan saham atau pasar cryptocurrency dengan tingkat fluktuasi tinggi, dan hindari untuk digunakan pada varietas rendah fluktuasi seperti blue chip saham besar.
Petunjuk risiko: Retrospeksi historis tidak mewakili keuntungan masa depan, ada risiko kerugian berturut-turut dalam strategi, manajemen risiko harus dilakukan secara ketat, dan performa bervariasi dalam berbagai kondisi pasar.
/*backtest
start: 2026-01-07 15:30:00
end: 2026-03-15 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"XAG_USDT","balance":500000}]
*/
//@version=5
strategy("Quant Trend Engine Long Only v2 - Manual Leverage Fixed", overlay=true)
// === Core lengths ===
fastLen = input.int(18, "Fast EMA")
midLen = input.int(50, "Mid EMA")
slowLen = input.int(120, "Slow EMA")
smoothLen = input.int(3, "EMA Smoothing")
pullbackLen = input.int(8, "Pullback Lookback")
breakoutLen = input.int(20, "Breakout Length")
effLen = input.int(18, "Efficiency Length")
persistLen = input.int(7, "Persistence Length")
momLen = input.int(12, "Momentum Length")
slopeLen = input.int(10, "Slope Length")
atrLen = input.int(14, "ATR Length")
atrBaseLen = input.int(40, "ATR Baseline Length")
// === Thresholds ===
minScore = input.float(5.0, "Minimum Entry Score", step=0.25)
exitScore = input.float(2.5, "Weak Trend Exit Score", step=0.25)
minSepPerc = input.float(0.30, "Min EMA Separation %", step=0.05)
minSlowSlopePerc = input.float(0.03, "Min Slow Slope %", step=0.01)
minEff = input.float(0.33, "Min Efficiency", step=0.01)
minAtrRegime = input.float(0.95, "Min ATR Regime", step=0.05)
minBreakoutAtr = input.float(0.15, "Min Breakout ATR Strength", step=0.05)
pullbackAtrMult = input.float(0.90, "Pullback Distance ATR", step=0.05)
reclaimAtrMult = input.float(0.15, "Reclaim Distance ATR", step=0.05)
cooldownBars = input.int(5, "Cooldown Bars After Exit")
// === Risk ===
leverage = input.float(2.0, "Leverage", step=0.1, minval=0.1)
hardStopPerc = input.float(2.0, "Hard Stop %", step=0.1)
trailAtrMult = input.float(2.8, "ATR Trail Mult", step=0.1)
profitLockAtrMult = input.float(20.8, "Profit Lock ATR Mult", step=0.1)
// === Smoothed EMAs ===
fast = ta.ema(ta.ema(close, fastLen), smoothLen)
mid = ta.ema(ta.ema(close, midLen), smoothLen)
slow = ta.ema(ta.ema(close, slowLen), smoothLen)
// === Regime structure ===
bullStack = fast > mid and mid > slow
sepPerc = slow != 0 ? math.abs(fast - slow) / slow * 100 : 0.0
sepOk = sepPerc >= minSepPerc
fastSlope = fast[slopeLen] != 0 ? (fast - fast[slopeLen]) / fast[slopeLen] * 100 : 0.0
midSlope = mid[slopeLen] != 0 ? (mid - mid[slopeLen]) / mid[slopeLen] * 100 : 0.0
slowSlope = slow[slopeLen] != 0 ? (slow - slow[slopeLen]) / slow[slopeLen] * 100 : 0.0
slopeOk = slowSlope >= minSlowSlopePerc and midSlope > 0 and fastSlope > 0
// === Path efficiency ===
netMove = math.abs(close - close[effLen])
stepMove = 0.0
for i = 1 to effLen
stepMove += math.abs(close[i - 1] - close[i])
efficiency = stepMove != 0 ? netMove / stepMove : 0.0
effOk = efficiency >= minEff
// === Momentum persistence ===
upBars = 0.0
for i = 0 to persistLen - 1
upBars += close[i] > close[i + 1] ? 1 : 0
persistRatio = persistLen > 0 ? upBars / persistLen : 0.0
momRaw = close[momLen] != 0 ? (close - close[momLen]) / close[momLen] * 100 : 0.0
momOk = momRaw > 0 and persistRatio >= 0.57
// === Volatility regime ===
atr = ta.atr(atrLen)
atrBase = ta.sma(atr, atrBaseLen)
atrRegime = atrBase != 0 ? atr / atrBase : 0.0
atrOk = atrRegime >= minAtrRegime
// === Breakout quality ===
hh = ta.highest(high, breakoutLen)[1]
breakoutDist = close - hh
breakoutStrength = atr != 0 ? breakoutDist / atr : 0.0
breakoutOk = close > hh and breakoutStrength >= minBreakoutAtr
// === Pullback / reclaim logic ===
pullbackLow = ta.lowest(low, pullbackLen)
distFromFastAtr = atr != 0 ? (fast - pullbackLow) / atr : 0.0
deepEnoughPullback = distFromFastAtr >= pullbackAtrMult
reclaimFast = close > fast and close[1] <= fast[1]
reclaimMid = close > mid and close[1] <= mid[1]
reclaimStrength = atr != 0 ? (close - fast) / atr : 0.0
reclaimOk = (reclaimFast or reclaimMid) and reclaimStrength >= reclaimAtrMult
// === Transition memory ===
bullCross = ta.crossover(fast, mid) or ta.crossover(fast, slow) or ta.crossover(mid, slow)
barsSinceBullCross = ta.barssince(bullCross)
recentTrendBirth = barsSinceBullCross >= 0 and barsSinceBullCross <= 14
// === Weighted score ===
trendScore = 0.0
trendScore += bullStack ? 1.50 : 0.0
trendScore += sepOk ? 0.90 : 0.0
trendScore += slopeOk ? 1.10 : 0.0
trendScore += effOk ? 1.00 : 0.0
trendScore += atrOk ? 0.80 : 0.0
trendScore += momOk ? 1.00 : 0.0
trendScore += breakoutOk ? 1.25 : 0.0
trendScore += reclaimOk ? 1.10 : 0.0
// === Entry models ===
trendContinuationEntry = bullStack and breakoutOk and slopeOk and effOk and momOk
pullbackReentry = bullStack and sepOk and slopeOk and deepEnoughPullback and reclaimOk and effOk
earlyTrendEntry = recentTrendBirth and bullStack and sepOk and slopeOk and atrOk and momOk
// === Cooldown ===
var int lastExitBar = na
cooldownOk = na(lastExitBar) or bar_index - lastExitBar > cooldownBars
// === Final entry ===
enterLong = strategy.position_size == 0 and cooldownOk and trendScore >= minScore and close > slow and (trendContinuationEntry or pullbackReentry or earlyTrendEntry)
// === Manual leveraged sizing only ===
equity = math.max(strategy.equity, 0)
positionValue = equity * leverage
qty = positionValue > 0 ? positionValue / (close * syminfo.pointvalue) : 0.0
// === Entry tracking / mandatory 1 full candle hold ===
var int entryBarIndex = na
justOpened = strategy.position_size > 0 and strategy.position_size[1] == 0
if justOpened
entryBarIndex := bar_index
canExitNow = strategy.position_size > 0 and not na(entryBarIndex) and bar_index > entryBarIndex
// === Entry order ===
if enterLong and qty > 0
strategy.entry("Long", strategy.long, qty=qty)
// === Risk logic ===
hardStopPrice = strategy.position_size > 0 ? strategy.position_avg_price * (1 - hardStopPerc / 100) : na
var float trailStop = na
var float highSinceEntry = na
highSinceEntry := strategy.position_size > 0 ? (na(highSinceEntry) ? high : math.max(highSinceEntry, high)) : na
rawTrail = strategy.position_size > 0 ? close - atr * trailAtrMult : na
profitLock = strategy.position_size > 0 ? highSinceEntry - atr * profitLockAtrMult : na
combinedTrail = strategy.position_size > 0 ? math.max(rawTrail, profitLock) : na
trailStop := strategy.position_size > 0 ? (na(trailStop) ? combinedTrail : math.max(trailStop, combinedTrail)) : na
// === Exit logic ===
bearCross = ta.crossunder(fast, mid) or ta.crossunder(fast, slow)
structureBreak = close < mid and fast < mid
scoreWeak = trendScore <= exitScore
momentumFailure = persistRatio < 0.40 and momRaw < 0
regimeFailure = atrRegime < 0.80 and efficiency < 0.25
exitLong = strategy.position_size > 0 and canExitNow and (bearCross or structureBreak or scoreWeak or momentumFailure or regimeFailure)
// Only allow stop/trailing exits after 1 full candle has passed
if strategy.position_size > 0 and canExitNow
strategy.exit("Risk Exit", from_entry="Long", stop=math.max(hardStopPrice, trailStop))
justClosed = strategy.position_size[1] > 0 and strategy.position_size == 0
if justClosed
lastExitBar := bar_index
trailStop := na
highSinceEntry := na
entryBarIndex := na
if exitLong
strategy.close("Long")
// === Plots ===
plot(fast, color=color.green, linewidth=2, title="Fast EMA")
plot(mid, color=color.orange, linewidth=2, title="Mid EMA")
plot(slow, color=color.red, linewidth=2, title="Slow EMA")
plot(strategy.position_size > 0 ? trailStop : na, color=color.blue, linewidth=2, title="Adaptive Trail")
plot(trendScore, title="Trend Score", color=color.aqua)
plot(efficiency, title="Efficiency", color=color.fuchsia)
plot(atrRegime, title="ATR Regime", color=color.yellow)
plot(breakoutStrength, title="Breakout Strength", color=color.lime)
plot(persistRatio, title="Persistence Ratio", color=color.white)