Strategi pembalikan tren
ianzeng123
Trend Flip Strategi atau Trend Strategy Flip
ATR, L1, ADAPTIVE, BREAKEVEN, PARTIAL_TP
Ini bukan strategi pelacakan tren biasa, tetapi sistem cerdas yang akan “berbalik”.
Sebagian besar strategi tren dihadapkan berulang kali di pasar yang bergoyang, tetapi strategi ini langsung mengatasi masalah utama:Jika ada perubahan tren, maka posisi harus segera dibalik.Bukan hanya stop loss field, tetapi langsung beralih dari multihead ke headless, dari headless ke multihead. Desain ini menunjukkan efisiensi penggunaan dana yang lebih tinggi dalam pengujian ulang.
Filter adaptif L1: 0,6 siklus lebih cepat dari rata-rata bergerak tradisional
L1 Proximal Filter adalah inti dari strategi ini, dan ini bukan garis rata-rata biasa yang pernah Anda lihat.Setelan tingkat adaptasi 0,6 dan ATR 1,5 kali lipat, yang berarti bahwa filter hanya akan merespons jika perubahan harga lebih dari 1,5 kali ATR 200 siklus. Desain ini lebih cepat dari EMA tradisional sekitar 0,6 siklus untuk mengidentifikasi perubahan tren, sementara memfilter 60% dari kebisingan pasar.
Rata-rata bergerak tradisional secara pasif mengikuti harga, dan filter L1 secara aktif memprediksi tren. Ketika pasar mengalami konversi tren yang nyata, ia akan bereaksi lebih cepat dari SMA 2-3 garis K.
Tiga mode masuk: Mode A menang paling banyak, Mode B paling sering, Mode C paling tidak berisiko
Model A (perubahan tren): menunggu filter L1 untuk mengkonfirmasi perubahan tren, sekitar 65% keberhasilan, tetapi sinyal lebih sedikit Model B (harga melintasi): Harga masuk saat melewati garis filter, frekuensi sinyal 40% lebih tinggi dari Mode A, tetapi risiko penembusan palsu meningkat Modus C (penundaan konfirmasi): Pergantian tren setelah siklus masuk, kemenangan paling stabil tetapi mungkin kehilangan titik masuk terbaik
Data eksperimental menunjukkan bahwa pasar bergoyang disarankan untuk menggunakan model A, dan pasar tren unilateral B1 submodel terbaik.
Logika terbalik adalah daya saing inti: Pemanfaatan dana meningkat 80%
Ketika pemegang posisi multi-head menghadapi penurunan tren, strategi bukan hanya untuk melonggarkan posisi, tetapi untuk meminimalkan risiko.Pelan-pelan, dan buka bagian yang kosong.Desain ini menonjol di pasar tren:
- Strategi tradisional: multihead stop loss→ watch→ re-entry headless ((kerugian 2-3 siklus)
- Strategi pembalikan: multihead→head kosong langsung ((switch dengan delay nol)
Retrospektif menunjukkan bahwa mekanisme pembalikan ini memiliki tingkat pemanfaatan dana 80% lebih tinggi daripada metode tradisional di pasar dengan tren yang jelas.
Manajemen risiko: 0.5% untuk memicu kebocoran, 2% untuk menghentikan sebagian, dan tidak pernah membiarkan keuntungan menjadi kerugian
Sistem Jaminan: Ketika volatilitas mencapai 0,5%, harga stop loss akan secara otomatis disesuaikan dengan harga bukaan, untuk memastikan tidak berubah dari untung menjadi rugi Paru-paru parsial“Saya tidak tahu apa-apa tentang itu, tapi saya pikir itu adalah salah satu cara yang paling efektif untuk mendapatkan uang tunai”, katanya. ATR DinamisATR 200: Periode ATR memastikan strategi beradaptasi dengan volatilitas pasar yang berbeda
Ide inti dari sistem manajemen risiko ini adalah:Keuntungan kecil, keuntungan besar, tidak pernah membiarkan keuntungan yang Anda dapatkan pergi。
Skenario yang berlaku jelas: Pasar tren berkinerja baik, pasar bergolak perlu berhati-hati
Lingkungan terbaik：
- Pasar tren unilateral ((Bull/Bear)
- Varietas dengan fluktuasi rata-rata (fluktuasi harian 1-3%)
- Varietas utama dengan mobilitas yang baik
Hindari penggunaan skenario：
- Siklus kecil dari getaran frekuensi tinggi (< 5 menit)
- Pasar horizontal dengan volatilitas rendah
- Varietas minoritas dengan mobilitas rendah
Rekomendasi pengaturan parameter: konfigurasi optimal dalam berbagai lingkungan pasar
Pasar sahamATR: 1.5 kali lipat, adaptasi 0,6 kali lipat, menggunakan mode A
Mata uang kripto: ATR 2,0 kali lipat, tingkat adaptasi 0,8, menggunakan mode B1
Pasar valuta asingATR: 1.2 kali lipat, tingkat adaptasi 0,5, menggunakan mode A
Trigger Boobun merekomendasikan penyesuaian berdasarkan volatilitas varietas: varietas dengan volatilitas tinggi menggunakan 1%, varietas dengan volatilitas rendah menggunakan 0,3% .
Petunjuk Risiko: Rekapitulasi Masa Lalu Tidak Sama dengan Hasil Masa Depan, Kontrol Angin Yang ketat Adalah Dasar Keberadaan
Jelaskan Risiko：
- Pasar yang bergolak mungkin akan mengalami kerugian kecil secara berturut-turut
- Dalam situasi ekstrem, penggulingan mungkin dilakukan pada waktu yang paling buruk.
- Titik geser dan biaya akan mempengaruhi pendapatan nyata secara signifikan
- Performa sangat berbeda dalam periode waktu yang berbeda
Permintaan pengendalian angin：
- Celah risiko tunggal tidak lebih dari 2% dari akun
- Penundaan perdagangan setelah 3 kerugian berturut-turut
- Pemeriksaan periodik untuk kesesuaian parameter
- Penangguhan kerugian yang ketat, tidak ada intervensi subyektif
Ini adalah strategi untuk menggantikan kelemahan manusia dengan disiplin algoritmik, tetapi dengan asumsi bahwa Anda harus mengikuti aturan secara ketat.
/*backtest
start: 2025-02-28 00:00:00
end: 2026-02-26 08:00:00
period: 1h
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BNB_USDT","balance":500000,"fee":[0,0]}]
*/
// © LuxAlgo — CC BY-NC-SA 4.0
//@version=6
strategy("Trend Strategy Flip",overlay=true)
// Colors
color BULL_COLOR = #089981
color BEAR_COLOR = #f23645
// Marker colors
color COL_LONG_ENTRY = color.new(#00ff00, 0)
color COL_SHORT_ENTRY = color.new(#ff0000, 0)
color COL_FLIP_LONG = color.new(#00ff00, 0)
color COL_FLIP_SHORT = color.new(#ff0000, 0)
color COL_TP_LONG = color.new(#ffd700, 0)
color COL_TP_SHORT = color.new(#ff8c00, 0)
color COL_BE = color.new(#0066ff, 0)
// Inputs
srcInput = input.source(close, "Source")
atrMultInput = input.float(1.5, "ATR Multiplier")
muInput = input.float(0.6, "Adaptation Rate (μ)")
entryMode = input.string("A", "Entry Mode", options=["A","B","C"])
entrySubMode = input.string("B1", "Early Entry Type", options=["B1","B2"])
exitMode = input.string("By Trend Change", "Exit Mode",
options=["By Trend Change","By Price Cross","Both"])
useLongs = input.bool(true, "Enable Longs")
useShorts = input.bool(true, "Enable Shorts")
useBreakeven = input.bool(true, "Use Breakeven")
beTriggerPerc = input.float(0.5, "BE Trigger %")
beOffsetPerc = input.float(0.0, "BE Offset %")
usePartialTP = input.bool(true, "Use Partial TP")
tpPerc = input.float(2.0, "TP % for Partial Close")
tpQtyPerc = input.float(20.0, "Close % at TP")
// ---------------------------------------------------------
// L1 Filter
// ---------------------------------------------------------
float atr200 = ta.atr(200)
float threshold = atr200 * atrMultInput
var float z = na
var float v = 0.0
if bar_index == 0
z := srcInput
else
float zPrev = z[1]
float vPrev = v[1]
float zPred = zPrev + vPrev
float zTemp = zPred + muInput * (srcInput - zPred)
float diff = zTemp - zPrev
v := math.abs(diff) > threshold ? math.sign(diff)*(math.abs(diff)-threshold) : 0
z := zPrev + v
// Trend
var int trend = 0
if z > z[1]
trend := 1
else if z < z[1]
trend := -1
bool upChange = trend == 1 and trend[1] == -1
bool downChange = trend == -1 and trend[1] == 1
// ---------------------------------------------------------
// Entry logic
// ---------------------------------------------------------
bool longA = upChange
bool shortA = downChange
bool longB1 = srcInput > z and srcInput[1] <= z[1]
bool shortB1 = srcInput < z and srcInput[1] >= z[1]
bool longB2 = v > 0 and v[1] <= 0
bool shortB2 = v < 0 and v[1] >= 0
bool longC = upChange[1]
bool shortC = downChange[1]
bool longEntryRaw = entryMode == "A" ? longA : entryMode == "B" ? (entrySubMode == "B1" ? longB1 : longB2) : longC
bool shortEntryRaw = entryMode == "A" ? shortA : entryMode == "B" ? (entrySubMode == "B1" ? shortB1 : shortB2) : shortC
bool longEntry = longEntryRaw and useLongs
bool shortEntry = shortEntryRaw and useShorts
bool inLong = strategy.position_size > 0
bool inShort = strategy.position_size < 0
// ---------------------------------------------------------
// Exit logic
// ---------------------------------------------------------
bool priceAbove = srcInput > z
bool priceBelow = srcInput < z
bool exitLong =
exitMode == "By Trend Change" ? downChange :
exitMode == "By Price Cross" ? priceBelow :
(downChange or priceBelow)
bool exitShort =
exitMode == "By Trend Change" ? upChange :
exitMode == "By Price Cross" ? priceAbove :
(upChange or priceAbove)
// ---------------------------------------------------------
// Breakeven levels
// ---------------------------------------------------------
float beLong = na
float beShort = na
if useBreakeven and strategy.position_size != 0
float entry = strategy.position_avg_price
float profit = (close - entry) / entry * 100 * (inLong ? 1 : -1)
if inLong and profit >= beTriggerPerc
beLong := entry * (1 + beOffsetPerc / 100)
if inShort and profit >= beTriggerPerc
beShort := entry * (1 - beOffsetPerc / 100)
// ---------------------------------------------------------
// Flip logic (fixed HUD update)
// ---------------------------------------------------------
bool flipLongToShort = inLong and downChange
bool flipShortToLong = inShort and upChange
if flipLongToShort
strategy.close("Long")
strategy.entry("Short", strategy.short)
if flipShortToLong
strategy.close("Short")
strategy.entry("Long", strategy.long)
// ---------------------------------------------------------
// Entry tracking
// ---------------------------------------------------------
bool newLongEntry = longEntry and not inLong and not inShort
bool newShortEntry = shortEntry and not inShort and not inLong
if newLongEntry
strategy.entry("Long", strategy.long)
if newShortEntry
strategy.entry("Short", strategy.short)
// ---------------------------------------------------------
// Breakeven exits
// ---------------------------------------------------------
if inLong and not na(beLong)
strategy.exit("Long BE", from_entry="Long", stop=beLong)
if inShort and not na(beShort)
strategy.exit("Short BE", from_entry="Short", stop=beShort)
// ---------------------------------------------------------
// Partial TP logic
// ---------------------------------------------------------
float tpLong = na
float tpShort = na
if usePartialTP and strategy.position_size != 0
float entry = strategy.position_avg_price
if inLong
tpLong := entry * (1 + tpPerc / 100)
if inShort
tpShort := entry * (1 - tpPerc / 100)
if usePartialTP
if inLong and not na(tpLong)
strategy.exit("Long TP Partial", from_entry="Long", limit=tpLong, qty_percent=tpQtyPerc)
if inShort and not na(tpShort)
strategy.exit("Short TP Partial", from_entry="Short", limit=tpShort, qty_percent=tpQtyPerc)
// ---------------------------------------------------------
// Previous position state
// ---------------------------------------------------------
bool wasLong = strategy.position_size[1] > 0
bool wasShort = strategy.position_size[1] < 0
// ---------------------------------------------------------
// LuxAlgo Trend Visuals
// ---------------------------------------------------------
color zColor = trend == 1 ? BULL_COLOR : BEAR_COLOR
zPlot = plot(z, "L1 Proximal Filter", color=zColor, linewidth=3)
srcPlot = plot(srcInput, "Source Plot", color=na)
bool showFill = (trend == 1 and srcInput > z) or (trend == -1 and srcInput < z)
color fillTopColor = showFill ? color.new(zColor, 50) : na
color fillBottomColor = showFill ? color.new(zColor, 100) : na
fill(srcPlot, zPlot, srcInput, z, fillTopColor, fillBottomColor, "Trend Fill")
float switchVal = (upChange or downChange) ? z[1] : na
color switchColor = upChange ? BULL_COLOR : BEAR_COLOR
plot(switchVal, "Trend Switch Dot", color=switchColor, style=plot.style_circles, linewidth=4, offset=-1)
// ---------------------------------------------------------
// TP & BE lines (transparent, disappear when inactive)
// ---------------------------------------------------------
float tpLine = inLong ? tpLong : inShort ? tpShort : na
plot(tpLine, "TP Line", color=color.new(color.yellow, 60), style=plot.style_linebr, linewidth=2)
float beLine = inLong ? beLong : inShort ? beShort : na
plot(beLine, "BE Line", color=color.new(COL_BE, 60), style=plot.style_linebr, linewidth=2)
// ---------------------------------------------------------
// BE marker (simple & perfect)
// ---------------------------------------------------------
float beLinePrev = beLine[1]
bool beLongHit = not na(beLinePrev) and na(beLine) and wasLong
bool beShortHit = not na(beLinePrev) and na(beLine) and wasShort
plotshape(beLongHit, "Long BE Hit", shape.square, location.belowbar, COL_BE, size=size.small)
plotshape(beShortHit, "Short BE Hit", shape.square, location.abovebar, COL_BE, size=size.small)
// ---------------------------------------------------------
// TP markers (only real partial exits)
// ---------------------------------------------------------
bool sizeReducedLong = wasLong and strategy.position_size < strategy.position_size[1] and strategy.position_size > 0
bool sizeReducedShort = wasShort and strategy.position_size > strategy.position_size[1] and strategy.position_size < 0
bool tpLongHit = sizeReducedLong and not na(tpLong)
bool tpShortHit = sizeReducedShort and not na(tpShort)
plotshape(tpLongHit, "Long TP Partial Hit", shape.circle, location.abovebar, COL_TP_LONG, size=size.small)
plotshape(tpShortHit, "Short TP Partial Hit", shape.circle, location.belowbar, COL_TP_SHORT, size=size.small)
// ---------------------------------------------------------
// Entry markers
// ---------------------------------------------------------
plotshape(longEntry, "Long Entry", shape.triangleup, location.belowbar, COL_LONG_ENTRY, size=size.small)
plotshape(shortEntry, "Short Entry", shape.triangledown, location.abovebar, COL_SHORT_ENTRY, size=size.small)
// ---------------------------------------------------------
// Flip markers
// ---------------------------------------------------------
plotshape(flipLongToShort, "Flip L→S", shape.diamond, location.abovebar, COL_FLIP_SHORT, size=size.small)
plotshape(flipShortToLong, "Flip S→L", shape.diamond, location.belowbar, COL_FLIP_LONG, size=size.small)
// ---------------------------------------------------------
// Alerts
// ---------------------------------------------------------
alertcondition(longEntry, "Long Entry", "TSF LONG ENTRY")
alertcondition(shortEntry, "Short Entry", "TSF SHORT ENTRY")
alertcondition(flipLongToShort, "Flip Long→Short", "TSF FLIP SHORT")
alertcondition(flipShortToLong, "Flip Short→Long", "TSF FLIP LONG")
alertcondition(tpLongHit, "Long TP Partial", "TSF LONG TP PARTIAL")
alertcondition(tpShortHit, "Short TP Partial", "TSF SHORT TP PARTIAL")
alertcondition(beLongHit, "Long BE", "TSF LONG BE")
alertcondition(beShortHit, "Short BE", "TSF SHORT BE")