Stratégies de tendance basées sur les ratios de volume
ChaoZhang
Cet article détaille une stratégie quantitative qui permet de déterminer la direction d’une tendance en fonction du ratio de transaction. Cette stratégie génère un signal d’achat et de vente en calculant une ligne moyenne de transaction à vide.
Premièrement, les principes stratégiques
L’indicateur central de la stratégie est le volume de transactions en surplus. Les étapes de calcul sont les suivantes:
Calculer le volume de transactions effectuées dans la journée.
Si la ligne K est jugée à plusieurs têtes, le volume de transaction est noté comme le volume de transaction à plusieurs parties (Bull Volume).
Si la ligne K est considérée comme vide, le volume d’échanges est noté comme étant le volume d’échanges de la partie vide (Bear Volume).
Calculer les moyennes mobiles des échanges entre les parties multiples et les parties vides.
Un signal d’achat est généré lorsque la moyenne mobile à plusieurs faces est traversée par la moyenne mobile à face cachée; un signal de vente est généré au contraire.
Le filtrage est effectué à l’aide d’indicateurs de taux de variation des prix, et les transactions ne sont effectuées que lorsque la tendance est claire.
Le stop loss est réglé sur le signal pour bloquer le gain.
Ainsi, la direction de la tendance peut être déterminée par la proportion d’espace libre de la quantité de transactions et le filtrage peut être facilité par l’indicateur du taux de variation des prix, ce qui améliore la qualité du signal. Le paramètre Stop Loss Stop Loss permet également de contrôler les pertes par transaction.
Deux, les avantages stratégiques
Le plus grand avantage de cette stratégie est l’utilisation du volume de transactions pour déterminer la direction de la tendance, qui est l’une des méthodes les plus élémentaires pour déterminer la tendance. Le volume de transactions peut refléter le comportement des acteurs du marché.
En outre, l’indicateur de volume de transaction peut également refléter les signaux de rupture à l’avance et est plus sensible. Comparé à l’utilisation de l’indicateur de prix uniquement, il peut capturer le revirement de tendance plus tôt.
Enfin, le filtrage en combinaison avec l’indicateur du taux de variation des prix a amélioré la qualité du signal.
Troisièmement, les risques potentiels
Malgré les avantages de cette stratégie, les risques suivants sont à prendre en compte:
Tout d’abord, il faut être prudent avec les paramètres de l’indicateur de trafic pour éviter les faux signaux.
Deuxièmement, le fait de s’appuyer sur un seul indicateur est susceptible d’invalider les prix de rupture. Il faut vérifier plusieurs combinaisons d’indicateurs.
Enfin, un arrêt de perte trop proche du réglage peut entraîner un risque de perte de perte.
Quatrième partie, résumé
Cet article présente en détail une stratégie de quantification qui utilise le ratio de transaction pour déterminer les tendances. Elle peut générer des signaux de transaction en calculant une moyenne de transaction de transaction de transaction.
/*backtest
start: 2023-08-14 00:00:00
end: 2023-09-13 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=4
// Based on Volume Flow v3 indicator by oh92
strategy("Volume Flow BF", overlay=false, initial_capital=10000, default_qty_type=strategy.percent_of_equity, default_qty_value=100, commission_type=strategy.commission.percent, commission_value=0.0)
/////////////// Time Frame ///////////////
testStartYear = input(2017, "Backtest Start Year")
testStartMonth = input(1, "Backtest Start Month")
testStartDay = input(1, "Backtest Start Day")
testPeriodStart = timestamp(testStartYear,testStartMonth,testStartDay, 0, 0)
testStopYear = input(2019, "Backtest Stop Year")
testStopMonth = input(12, "Backtest Stop Month")
testStopDay = input(31, "Backtest Stop Day")
testPeriodStop = timestamp(testStopYear,testStopMonth,testStopDay, 0, 0)
testPeriod() => true
maType = input(title="Moving Average Type", options=["Simple", "Exponential", "Double Exponential"], defval="Simple")
length = input(6, title="MA Length")
x = input(3.1, title="Factor For Breakout Candle")
// Basic Volume Calcs //
vol = volume
bull = close>open?vol:0
bear = open>close?vol:0
// Double EMA Function //
dema(src, len) => (2 * ema(src, len) - ema(ema(src, len), len))
// BULL Moving Average Calculation
bullma = maType == "Exponential" ? ema(bull, length) :
maType == "Double Exponential" ? dema(bull, length) :
sma(bull, length)
// BEAR Moving Average Calculation //
bearma = maType == "Exponential" ? ema(bear, length) :
maType == "Double Exponential" ? dema(bear, length) :
sma(bear, length)
///////////// Rate Of Change /////////////
source = close
roclength = input(12, minval=1)
pcntChange = input(2, minval=1)
roc = 100 * (source - source[roclength]) / source[roclength]
emaroc = ema(roc, roclength / 2)
isMoving() => emaroc > (pcntChange / 2) or emaroc < (0 - (pcntChange / 2))
/////////////// Strategy ///////////////
long = bullma > bearma and isMoving()
short = bullma < bearma and isMoving()
last_long = 0.0
last_short = 0.0
last_long := long ? time : nz(last_long[1])
last_short := short ? time : nz(last_short[1])
long_signal = crossover(last_long, last_short)
short_signal = crossover(last_short, last_long)
last_open_long_signal = 0.0
last_open_short_signal = 0.0
last_open_long_signal := long_signal ? open : nz(last_open_long_signal[1])
last_open_short_signal := short_signal ? open : nz(last_open_short_signal[1])
last_long_signal = 0.0
last_short_signal = 0.0
last_long_signal := long_signal ? time : nz(last_long_signal[1])
last_short_signal := short_signal ? time : nz(last_short_signal[1])
in_long_signal = last_long_signal > last_short_signal
in_short_signal = last_short_signal > last_long_signal
last_high = 0.0
last_low = 0.0
last_high := not in_long_signal ? na : in_long_signal and (na(last_high[1]) or high > nz(last_high[1])) ? high : nz(last_high[1])
last_low := not in_short_signal ? na : in_short_signal and (na(last_low[1]) or low < nz(last_low[1])) ? low : nz(last_low[1])
sl_inp = input(2.0, title='Stop Loss %') / 100
tp_inp = input(900.0, title='Take Profit %') / 100
take_level_l = strategy.position_avg_price * (1 + tp_inp)
take_level_s = strategy.position_avg_price * (1 - tp_inp)
since_longEntry = barssince(last_open_long_signal != last_open_long_signal[1])
since_shortEntry = barssince(last_open_short_signal != last_open_short_signal[1])
slLong = in_long_signal ? strategy.position_avg_price * (1 - sl_inp) : na
slShort = strategy.position_avg_price * (1 + sl_inp)
long_sl = in_long_signal ? slLong : na
short_sl = in_short_signal ? slShort : na
/////////////// Execution ///////////////
if testPeriod()
strategy.entry("Long", strategy.long, when=long)
strategy.entry("Short", strategy.short, when=short)
strategy.exit("Long Ex", "Long", stop=long_sl, limit=take_level_l, when=since_longEntry > 0)
strategy.exit("Short Ex", "Short", stop=short_sl, limit=take_level_s, when=since_shortEntry > 0)
///////////// Plotting /////////////
bgcolor(isMoving() ? long ? color.green : short ? color.red : na : color.white, transp=80)
bgcolor(long_signal ? color.lime : short_signal ? color.red : na, transp=30)
plot(bullma, color=color.lime, linewidth=1, transp=0, title="Bull MA", transp=10)
plot(bearma, color=color.red, linewidth=1, transp=0, title="Bear MA", transp=10)