Trendumkehrstrategie
ianzeng123
Trend-Umkehr-Strategie und Trend-Strategie-Flip
ATR, L1, ADAPTIVE, BREAKEVEN, PARTIAL_TP
Das ist keine gewöhnliche Trend-Tracking-Strategie, sondern ein intelligentes System, das “die Fresse umdreht”.
Die meisten Trendstrategien wurden in der Schwankungsstadt wiederholt aufgegriffen, aber diese Strategie löst direkt das Kernproblem:Wenn der Trend umkehrt, umkehren Sie sofort Ihre Position.Statt eines einfachen Verlust-Abschlusses schaltet man von der Mehrköpfe direkt auf die Leerköpfe und von den Leerköpfen direkt auf die Mehrköpfe. Diese Konstruktion zeigte in der Rückmeldung eine höhere Kapitalnutzungs-Effizienz.
L1 Adaptive Filter: 0,6 Zyklen schneller als der herkömmliche Moving Average
Die Strategie basiert auf dem L1 Proximal Filter, der nicht die gewöhnliche Durchschnittslinie ist, die Sie kennen.Selbstanpassungsrate 0,6 und 1,5-fache ATR-ModalitätDer Filter reagiert nur, wenn die Preisänderung mehr als das 1,5-fache der 200-Zyklus-ATR beträgt. Diese Konstruktion ist etwa 0,6 Zyklen schneller als die herkömmliche EMA, um Trendänderungen zu erkennen und 60% des Marktrausches zu filtern.
Traditionelle Moving Averages folgen den Preisen passiv, L1 Filter sind aktive Trend-Vorhersager. Wenn ein echter Trendwechsel auftritt, reagieren sie schneller als SMAs mit 2-3 K-Linien.
Drei Eintrittsarten: Modus A mit der höchsten Gewinnrate, Modus B mit der höchsten Häufigkeit und Modus C mit dem geringsten Risiko
Modell A (Veränderung der Tendenz)Warten auf die Bestätigung durch den L1-Filter, dass die Tendenz umgekehrt ist, mit einer Gewinnrate von etwa 65%, aber weniger Signalen Modell B (Preisübergang)Bei einem Preisbruch durch die Filterleine ist die Signalfrequenz um 40% höher als bei Modul A, aber die Gefahr eines falschen Durchbruchs steigt. Modus C (verzögerte Bestätigung)Der erste Zyklus, nach dem sich der Trend verändert hat, ist am stabilsten, kann aber den besten Einstiegspunkt verpassen.
Experimentelle Daten zeigen, dass ein Schaukelmarkt in Modell A und ein einseitiger Trendmarkt in Submodell B1 am besten funktioniert.
Umkehrlogik ist die Kernkompetenz: Kapitalnutzung steigt um 80%
Die Strategie ist nicht einfach, die Positionen zu schließen, sondern die Positionen zu halten, wenn ein Trend nach unten geht.Schnell die Multiplikatoren abflachen und den Leerkopf öffnen❚ Diese Art von Design zeichnet sich in den Trendmärkten aus:
- Traditionelle Strategie: Mehrköpfige Stop-Loss → Beobachtung → Wiedereintritt in die Luft ((Verlust 2-3 Zyklen)
- Umschaltstrategie: Mehrkopf → Direktkopf (Zero-Latency-Schaltung)
Die Rückmeldung ergab, dass diese Umkehrmechanismen eine um 80% höhere Kapitalnutzung aufweisen als herkömmliche Methoden in trendschaffenden Märkten.
Risikomanagement: 0,5% ausgelöst, 2% zum Stillstand gebracht, keine Gewinne zum Verlust
SicherungsmechanismusWenn die Bewegung 0,5% erreicht, wird der Stop-Loss-Preis automatisch in die Nähe des Eröffnungspreises angepasst, um sicherzustellen, dass er nicht von einem Gewinn zu einem Verlust wird. Teilweise Starrheit“Wenn der Kurs um 2% schwankt, wird automatisch 20% der Positionen abgewickelt, um die Gewinne zu sichern”. ATR-Dynamik-TrenchATR für die 200-Perioden-Periode, um sicherzustellen, dass die Strategie an die Volatilität verschiedener Märkte angepasst wird
Die Kernidee des Risikomanagementsystems ist:Kleine Verluste, große Gewinne, die man nicht verlieren lässt。
Die Szenarien sind eindeutig: Trendmärkte sind gut, Schokkelmärkte müssen vorsichtig sein
Bessere Umgebung：
- Einseitige Trendmärkte (Bull/Bär)
- Varianten mit mittlerer Schwankungsrate (täglich 1-3%)
- Hauptarten mit hoher Mobilität
Vermeiden Sie Szenen：
- Kleine Perioden von Hochfrequenzschwingungen (< 5 Minuten)
- Der Horizontale Markt mit sehr geringer Volatilität
- Kleine, nicht so flüssige Rassen
Empfehlungen für die Einstellung der Parameter: Optimale Konfiguration für verschiedene Marktumgebungen
AktienmarktATR-Faktor 1,5, Anpassungsrate 0,6, Modell A verwendet
KryptowährungenATR-Mehrzahl 2,0, Anpassungsrate 0,8, B1-Modus verwendet
DevisenmarktATR-Mehrzahl 1,2, Selbstanpassung 0,5, Modus A verwendet
Die Auslösung wird empfohlen, um die Variantenfluktuation anzupassen: 1% für hochfluktuative und 0,3% für niedrigfluktuative Sorten.
Risiko-Hinweis: Vergangenheit ist nicht gleichbedeutend mit zukünftigen Erträgen. Strenge Risikokontrollen sind die Grundlage für das Überleben
Die Risiken sind klar：
- Der US-Markt könnte in Folge von kleinen Verlusten leiden.
- In extremen Situationen kann die Umkehrung zur ungünstigsten Zeit durchgeführt werden.
- Die Einbußen und Gebühren beeinflussen die tatsächlichen Erträge erheblich.
- Die Ergebnisse variieren stark in verschiedenen Zeitspannen.
Windkontrolle erforderlich：
- Die einmalige Risikobereitschaft beträgt nicht mehr als 2% des Kontos
- Handel nach drei Verlusten in Folge ausgesetzt
- Regelmäßige Überprüfung der Anpassungsfähigkeit der Parameter
- Strenge Einhaltung der Schadensbegrenzung ohne subjektive Intervention
Das Wesen dieser Strategie ist es, menschliche Schwächen durch algorithmische Disziplin zu ersetzen, aber vorausgesetzt, man muss die Regeln genau befolgen.
/*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")