stratégie d'inversion de tendance
ianzeng123
Le retour de la tendance est une stratégie de retour de tendance.
ATR, L1, ADAPTIVE, BREAKEVEN, PARTIAL_TP
Ce n’est pas une stratégie de suivi de tendances ordinaire, mais un système intelligent qui “se retourne”
La plupart des stratégies de tendance ont été repoussées à plusieurs reprises dans les villes en crise, mais celle-ci a résolu directement le problème central:Si la tendance est inversée, inversez immédiatement la position.Au lieu d’un simple arrêt de perte, il s’agit d’une commutation directe de la tête multiple à la tête vide, de la tête vide à la tête multiple. Cette conception a montré une plus grande efficacité de l’utilisation des fonds dans le test de rétroaction.
Filtre adaptatif L1: 0,6 cycle plus rapide que la moyenne mobile traditionnelle
Le filtrage proximal L1 est au cœur de la stratégie, et ce n’est pas la moyenne ordinaire que vous avez vue.Le taux d’adaptation est de 0,6 et le multiplicateur d’ATR est de 1,5Le filtrage de l’EMA est plus rapide que celui de l’EMA traditionnel de 0,6 cycle pour identifier les changements de tendance, tout en filtrant 60% du bruit du marché.
Les moyennes mobiles traditionnelles suivent les prix de manière passive, tandis que les filtres L1 prédisent activement les tendances. Lorsqu’il y a un véritable changement de tendance, ils réagissent plus rapidement que les lignes K de 2 à 3 SMA.
Trois modes d’entrée: le mode A est le plus efficace, le mode B est le plus fréquent et le mode C est le moins risqué.
Modèle A (changement de tendance)Attendre que le filtre L1 confirme le renversement de la tendance, avec un taux de réussite d’environ 65%, mais moins de signaux Modèle B (prix traversé): entrée de prix en cas de rupture de filtres avec une fréquence de signal 40% supérieure à celle du modèle A, mais avec un risque accru de fausse rupture Mode C (confirmation retardée)Les résultats de la première manche ont été les plus stables, mais il est possible de rater le meilleur point d’entrée.
Selon les données expérimentales, il est recommandé d’utiliser le modèle A pour le marché oscillant et le modèle B1 pour le marché à tendance unilatérale.
La logique du renversement est le cœur de la compétitivité: l’utilisation des fonds a augmenté de 80%
Quand les détenteurs de positions à plusieurs têtes sont confrontés à une tendance à la baisse, la stratégie n’est pas de simplement se positionner, mais de se positionner.Enlevez immédiatement le polype et ouvrez le vide.❚ Ce type de design se démarque sur les marchés tendances:
- Stratégie traditionnelle: arrêt de plusieurs têtes → observation → reprise du jeu sans tête ((perte 2-3 cycles)
- Stratégie de retournement: multi-tête → tête vide directe ((zéro retard de commutation)
La rétroaction montre que ce mécanisme de retournement a un taux d’utilisation des fonds 80% plus élevé que les méthodes traditionnelles dans les marchés où la tendance est claire.
Gestion des risques: 0,5% pour déclencher la caution, 2% pour une suspension partielle et aucun profit pour une perte
Le mécanisme de garantie: lorsque la volatilité atteint 0,5%, le prix stop-loss s’ajuste automatiquement au prix d’ouverture pour s’assurer qu’il ne passe pas de profit à perte Particulièrement étourdiLa banque a décidé d’annuler la position de 20% en cas de hausse de 2%, afin d’assurer la sécurité de ses clients. Déclin dynamique du ATRATR à 200 cycles pour s’assurer que la stratégie est adaptée à la volatilité des différents marchés
L’idée de base de ce système de gestion des risques est la suivante:Petite perte, gros bénéfice, ne laissez pas les bénéfices vous échapper。
Les scénarios sont clairs: les marchés tendanciels ont bien performé et les marchés volatiles ont besoin de prudence
Le meilleur environnement：
- Marché à tendance unilatérale (bull/bear)
- Variété à fluctuation modérée (fluctuation quotidienne de 1 à 3%)
- Les variétés les plus courantes sont celles qui ont une grande mobilité.
Évitez les scénarios：
- Petite période de vibrations à haute fréquence (moins de 5 minutes)
- Un marché horizontal à très faible volatilité
- Variétés populaires à faible mobilité
Recommandations de paramètres: configuration optimale dans différents environnements de marché
Le marché boursier: ATR multiplié par 1,5, taux d’adaptation 0,6, mode A utilisé
Les crypto-monnaies: ATR multiplié par 2,0, taux d’adaptation 0,8, mode B1 utilisé
Le marché des changes: ATR multiplié par 1,2, taux d’auto-adaptation 0,5, mode A utilisé
Le coupon déclenche des recommandations d’ajustement en fonction de la volatilité de la variété: 1% pour les variétés à forte volatilité et 0,3% pour les variétés à faible volatilité.
Avertissement: les retours passés ne sont pas synonymes de gains futurs, et la gestion rigoureuse des risques est essentielle pour survivre
Les risques sont clairs：
- Les pertes mineures pourraient se poursuivre sur les marchés en crise
- Dans les cas extrêmes, le renversement peut être effectué au pire moment.
- Les points de glissement et les frais de traitement ont une incidence significative sur les bénéfices réels
- Les performances varient considérablement selon les périodes.
Besoin de contrôle du vent：
- Une seule prise de risque ne dépasse pas 2% du compte
- Suspension des transactions après 3 pertes consécutives
- Vérifiez régulièrement la conformité des paramètres
- L’arrêt des pertes est strictement appliqué, aucune intervention subjective n’est autorisée
L’essence de cette stratégie est de remplacer la faiblesse humaine par la discipline algorithmique, mais à condition que vous soyez strictement réglementé.
/*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")