Stratégie de swing trading adaptative basée sur les cassures de prix
Date de création:
2023-12-04 14:34:13
Dernière modification:
2023-12-04 14:34:13
Copier:
0
Nombre de clics:
672
ChaoZhang
1
Suivre
1619
Abonnés
Aperçu
Cette stratégie permet d’identifier les tendances du marché en fonction des points de rupture des prix et de juger les grandes tendances en combinaison avec des indicateurs d’adaptation pour capturer les occasions de revirement des prix à court terme. La stratégie est adaptée aux transactions de crypto-monnaie à forte volatilité.
Principe de stratégie
- Identifier le point d’extrême prix comme limite de la voie.
- Calculer le MA de l’indicateur d’oscillation adaptatif pour déterminer la direction de la tendance générale. Plus le MA est élevé, plus le momentum est élevé.
- Un signal d’achat est généré lorsque le prix franchit la ligne supérieure du canal vers le haut; un signal de vente est généré lorsque le prix franchit la ligne inférieure du canal vers le bas.
- Le stop loss est fixé à 1% du prix d’entrée.
Analyse des avantages
- Les canaux de prix sont adaptatifs et permettent de déterminer avec précision les points de basculement des tendances.
- L’indicateur de fluctuation est utilisé pour juger de la tendance générale et éviter de perdre la direction générale dans une tendance de choc.
- Une stratégie de retournement, adaptée à la capture de rebonds à court terme.
Analyse des risques
- Dans un contexte de forte baisse continue, il est facile de déclencher plusieurs points de rupture, ce qui entraîne des pertes importantes.
- Les achats et les ventes ont augmenté les frais de transaction.
- Il est nécessaire de déterminer manuellement l’heure d’entrée, et les transactions entièrement automatisées présentent un risque de surcodage.
Direction d’optimisation
- Optimiser les paramètres de l’AM pour mieux juger de l’évolution globale
- Augmentation de l’indicateur d’énergie, afin d’éviter le retour de signal de l’épuisement de l’énergie.
- Ajout de modèles d’apprentissage automatique pour optimiser dynamiquement les paramètres.
Résumer
L’idée générale de la stratégie est claire et présente une certaine valeur pratique. Cependant, il faut toujours faire attention à la maîtrise des risques de négociation pour éviter de causer de grandes pertes dans des circonstances particulières. La prochaine étape peut être optimisée à partir de plusieurs dimensions telles que le cadre global, les paramètres de l’indicateur et le contrôle des risques, ce qui rend les paramètres de la stratégie et les signaux de négociation plus fiables.
Code source de la stratégie
/*backtest
start: 2023-11-03 00:00:00
end: 2023-12-03 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
// @version = 4
// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © TradingGroundhog
// ||--- Cash & Date:
cash_amout = 10000
pyramid_val = 1
cash_given_per_lot = cash_amout/pyramid_val
startDate = input(title="Start Date",defval=13)
startMonth = input(title="Start Month",defval=9)
startYear = input(title="Start Year",defval=2021)
afterStartDate = (time >= timestamp(syminfo.timezone,startYear, startMonth, startDate, 0, 0))
// ||------------------------------------------------------------------------------------------------------
// ||--- Strategy:
strategy(title="TradingGroundhog - Strategy & Fractal V1 - Short term", overlay=true, max_bars_back = 4000, max_labels_count=500, commission_type=strategy.commission.percent, commission_value=0.00,default_qty_type=strategy.cash, default_qty_value= cash_given_per_lot, pyramiding=pyramid_val)
// ||------------------------------------------------------------------------------------------------------
// ||--- Fractal Recognition:
filterBW = input(true, title="filter Bill Williams Fractals:")
filterFractals = input(true, title="Filter fractals using extreme method:")
length = input(2, title="Extreme Window:")
regulartopfractal = high[4] < high[3] and high[3] < high[2] and high[2] > high[1] and high[1] > high[0]
regularbotfractal = low[4] > low[3] and low[3] > low[2] and low[2] < low[1] and low[1] < low[0]
billwtopfractal = filterBW ? false : (high[4] < high[2] and high[3] < high[2] and high[2] > high[1] and high[2] > high[0] ? true : false)
billwbotfractal = filterBW ? false : (low[4] > low[2] and low[3] > low[2] and low[2] < low[1] and low[2] < low[0] ? true : false)
ftop = filterBW ? regulartopfractal : regulartopfractal or billwtopfractal
fbot = filterBW ? regularbotfractal : regularbotfractal or billwbotfractal
topf = ftop ? high[2] >= highest(high, length) ? true : false : false
botf = fbot ? low[2] <= lowest(low, length) ? true : false : false
filteredtopf = filterFractals ? topf : ftop
filteredbotf = filterFractals ? botf : fbot
// ||------------------------------------------------------------------------------------------------------
// ||--- V1 : Added Swing High/Low Option
ShowSwingsHL = input(true)
highswings = filteredtopf == false ? na : valuewhen(filteredtopf == true, high[2], 2) < valuewhen(filteredtopf == true, high[2], 1) and valuewhen(filteredtopf == true, high[2], 1) > valuewhen(filteredtopf == true, high[2], 0)
lowswings = filteredbotf == false ? na : valuewhen(filteredbotf == true, low[2], 2) > valuewhen(filteredbotf == true, low[2], 1) and valuewhen(filteredbotf == true, low[2], 1) < valuewhen(filteredbotf == true, low[2], 0)
//---------------------------------------------------------------------------------------------------------
// ||--- V2 : Plot Lines based on the fractals.
showchannel = input(true)
//---------------------------------------------------------------------------------------------------------
// ||--- ZigZag:
showZigZag = input(true)
//----------------------------------------------------------------------------------------------------------
// ||--- Fractal computation:
istop = filteredtopf ? true : false
isbot = filteredbotf ? true : false
topcount = barssince(istop)
botcount = barssince(isbot)
vamp = input(title="VolumeMA", defval=2)
vam = sma(volume, vamp)
fractalup = 0.0
fractaldown = 0.0
up = high[3]>high[4] and high[4]>high[5] and high[2]<high[3] and high[1]<high[2] and volume[3]>vam[3]
down = low[3]<low[4] and low[4]<low[5] and low[2]>low[3] and low[1]>low[2] and volume[3]>vam[3]
fractalup := up ? high[3] : fractalup[1]
fractaldown := down ? low[3] : fractaldown[1]
//----------------------------------------------------------------------------------------------------------
// ||--- Fractal save:
fractaldown_save = array.new_float(0)
for i = 0 to 4000
if array.size(fractaldown_save) < 3
if array.size(fractaldown_save) == 0
array.push(fractaldown_save, fractaldown[i])
else
if fractaldown[i] != array.get(fractaldown_save, array.size(fractaldown_save)-1)
array.push(fractaldown_save, fractaldown[i])
if array.size(fractaldown_save) < 3
array.push(fractaldown_save, fractaldown)
array.push(fractaldown_save, fractaldown)
fractalup_save = array.new_float(0)
for i = 0 to 4000
if array.size(fractalup_save) < 3
if array.size(fractalup_save) == 0
array.push(fractalup_save, fractalup[i])
else
if fractalup[i] != array.get(fractalup_save, array.size(fractalup_save)-1)
array.push(fractalup_save, fractalup[i])
if array.size(fractalup_save) < 3
array.push(fractalup_save, fractalup)
array.push(fractalup_save, fractalup)
Bottom_1 = array.get(fractaldown_save, 0)
Bottom_2 = array.get(fractaldown_save, 1)
Bottom_3 = array.get(fractaldown_save, 2)
Top_1 = array.get(fractalup_save, 0)
Top_2 = array.get(fractalup_save, 1)
Top_3 = array.get(fractalup_save, 2)
//----------------------------------------------------------------------------------------------------------
// ||--- Fractal Buy Sell Signal:
bool Signal_Test = false
bool Signal_Test_OUT_TEMP = false
var Signal_Test_TEMP = false
longLossPerc = input(title="Long Stop Loss (%)", minval=0.0, step=0.1, defval=0.01) * 0.01
if filteredbotf and open < Bottom_1 and (Bottom_1 - open) / Bottom_1 >= longLossPerc
Signal_Test := true
if filteredtopf and open > Top_1
Signal_Test_TEMP := true
if filteredtopf and Signal_Test_TEMP
Signal_Test_TEMP := false
Signal_Test_OUT_TEMP := true
//----------------------------------------------------------------------------------------------------------
// ||--- Plotting:
//plotshape(filteredtopf, style=shape.triangledown, location=location.abovebar, color=color.red, text="•", offset=0)
//plotshape(filteredbotf, style=shape.triangleup, location=location.belowbar, color=color.lime, text="•", offset=0)
//plotshape(ShowSwingsHL ? highswings : na, style=shape.triangledown, location=location.abovebar, color=color.maroon, text="H", offset=0)
//plotshape(ShowSwingsHL ? lowswings : na, style=shape.triangleup, location=location.belowbar, color=color.green, text="L", offset=0)
plot(showchannel ? (filteredtopf ? high[2] : na) : na, color=color.black, offset=0)
plot(showchannel ? (filteredbotf ? low[2] : na) : na, color=color.black, offset=0)
plot(showchannel ? (highswings ? high[2] : na) : na, color=color.black, offset=-2)
plot(showchannel ? (lowswings ? low[2] : na) : na, color=color.black, offset=-2)
plotshape(Signal_Test, style=shape.flag, location=location.belowbar, color=color.yellow, offset=0)
plotshape(Signal_Test_OUT_TEMP, style=shape.flag, location=location.abovebar, color=color.white, offset=0)
//----------------------------------------------------------------------------------------------------------
// ||--- Buy And Sell:
strategy.entry(id="Long", long=true, when = Signal_Test and afterStartDate)
strategy.close_all(when = Signal_Test_OUT_TEMP and afterStartDate)
//----------------------------------------------------------------------------------------------------------