Strategi pembalikan trend
ianzeng123
Trend Flip Strategi atau Trend Flip Strategi
ATR, L1, ADAPTIVE, BREAKEVEN, PARTIAL_TP
Ini bukan strategi trend-following biasa, tetapi sistem pintar yang “mengubah muka”.
Walaupun kebanyakan strategi trend telah diulang-ulang dalam pasaran yang bergolak, strategi ini mengatasi masalah utama:Peralihan kedudukan segera apabila trend berbalik。 Bukan hanya berhenti dari kerugian, tetapi beralih langsung dari kepala kosong ke kepala kosong. Reka bentuk ini menunjukkan kecekapan penggunaan dana yang lebih tinggi dalam tinjauan balik.
Penapis L1 yang beradaptasi: 0.6 kitaran lebih cepat daripada purata bergerak tradisional
L1 Proximal Filter adalah strategi utama, dan ia bukanlah garis purata biasa yang anda pernah lihat.Tetapan penyesuaian diri 0.6, 1.5 kali ganda ATR, yang bermaksud penapis hanya akan bertindak balas apabila perubahan harga melebihi 1.5 kali ATR 200 kitaran. Reka bentuk ini mengesan perubahan trend sekitar 0.6 kitaran lebih cepat daripada EMA tradisional, sambil menyaring 60% daripada bunyi pasaran.
Rata-rata bergerak tradisional secara pasif mengikuti harga, penapis L1 secara aktif meramalkan trend. Apabila pasaran mengalami perubahan trend yang sebenar, ia akan bertindak balas lebih cepat daripada SMA 2-3 garis K.
Tiga mod kemasukan: Mod A mempunyai peluang tertinggi, Mod B mempunyai frekuensi tertinggi, Mod C mempunyai risiko terendah
Model A (perubahan trend): menunggu penapis L1 mengesahkan trend berbalik, kira-kira 65% kemenangan, tetapi kurang isyarat Model B (harga melintasi): Harga masuk ke dalam talian penapis penembusan, frekuensi isyarat 40% lebih tinggi daripada Mod A, tetapi risiko penembusan palsu meningkat Mod C ((penangguhan pengesahan): Permulaan selepas kitaran perubahan trend, kemenangan paling stabil tetapi mungkin terlepas titik permulaan terbaik
Data percubaan menunjukkan bahawa pasaran goyah disyorkan untuk menggunakan mod A, dan pasaran tren sebelah B1 adalah mod terbaik.
Logik terbalik adalah daya saing utama: Penggunaan dana meningkat 80 peratus
Apabila pemegang kedudukan berbilang kepala menghadapi perubahan tren, strategi bukan hanya untuk melonggarkan kedudukan, tetapiKeluarkan kepala dan buka kepala kosong.❚ Reka bentuk ini menonjol di pasaran trend:
- Strategi tradisional: banyak hentian hentian→ menonton→ masuk semula tanpa hulu ((kerugian 2-3 kitaran)
- Strategi pembalikan: multihead→head kosong langsung ((switch tanpa kelewatan)
Kajian menunjukkan bahawa mekanisme pembalikan ini mempunyai penggunaan dana 80% lebih tinggi daripada kaedah tradisional di pasaran yang jelas.
Pengurusan risiko: 0.5% untuk mencetuskan jaminan, 2% untuk menghentikan sebahagian, dan tidak membiarkan keuntungan menjadi kerugian
Mekanisme Jaminan: Apabila kenaikan harga mencapai 0.5%, harga stop loss akan disesuaikan secara automatik dengan harga pembukaan, memastikan ia tidak berubah dari keuntungan kepada kerugian Paru-paru parut: Apabila kenaikan 2% secara automatik meratakan kedudukan 20% untuk memastikan keuntungan anda terjamin Penurunan dinamik ATRATR 200: memastikan strategi menyesuaikan diri dengan turun naik pasaran yang berbeza
Ini adalah idea utama dalam sistem pengurusan risiko ini:Kegagalan kecil, keuntungan besar, tidak pernah melepaskan keuntungan yang diperoleh。
Skenario yang boleh digunakan jelas: pasaran trend menunjukkan prestasi yang baik, pasaran goyah perlu berhati-hati
Persekitaran terbaik：
- Pasaran trend unilateral ((Pasar lembu/bear)
- Varieti dengan kadar turun naik sederhana ((hari turun naik 1-3%)
- Varieti utama yang mempunyai kebolehan bergerak
Elakkan menggunakan adegan：
- Kitaran kecil gegaran frekuensi tinggi (kurang daripada 5 minit)
- Pasaran horizontal dengan kadar turun naik yang rendah
- Varieti kecil yang kurang bergerak
Cadangan tetapan parameter: konfigurasi optimum dalam keadaan pasaran yang berbeza
Pasaran sahamPekali ATR 1.5, kadar penyesuaian diri 0.6, menggunakan mod A
Mata wang kriptoPekali ATR 2.0, adaptasi diri 0.8, menggunakan mod B1
Pasaran pertukaran asingPekali ATR: 1.2, kadar penyesuaian diri: 0.5, menggunakan mod A
BOPEN mencadangkan untuk memicu penyesuaian mengikut kelembapan varieti: 1% untuk varieti yang berfluktuasi tinggi, 0.3% untuk varieti yang berfluktuasi rendah.
Petua Risiko: Pemantauan Sejarah Tidak Sama dengan Hasil Masa Depan, Pengendalian Angin Yang ketat Adalah Dasar Untuk Bertahan
Jelaskan risiko：
- Pasaran bergolak mungkin mengalami kerugian kecil berturut-turut
- Dalam keadaan yang melampau, penggulingan boleh dilakukan pada masa yang paling teruk.
- Titik tergelincir dan yuran akan menjejaskan pendapatan sebenar
- Perkembangan yang berbeza dalam tempoh masa yang berbeza
Keperluan kawalan angin：
- Celah risiko tunggal tidak melebihi 2% akaun
- Penangguhan perdagangan selepas 3 kerugian berturut-turut
- Semak kelayakan parameter secara berkala
- Penangguhan Kerosakan Berpatutan, Tiada Penglibatan Subjektif
Strategi ini adalah untuk menggantikan kelemahan manusia dengan disiplin algoritma, tetapi dengan syarat bahawa anda perlu mematuhi peraturan.
/*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")