Outil d'analyse de stratégie dynamique
ChaoZhang
Aperçu
L’idée principale de cette stratégie est de simuler les transactions en temps réel, de collecter des données de transactions hebdomadaires et de présenter les résultats statistiques sous forme de tableaux afin de voir plus intuitivement la performance de la stratégie. Elle nous aide à évaluer rapidement les profits et pertes de la stratégie, à identifier les périodes de temps où la stratégie ne fonctionne pas bien et à effectuer des ajustements et des optimisations de la stratégie en conséquence.
Principe de stratégie
Définir le début et la fin du cycle de calcul.
Définition de la précision des statistiques et du nombre de semaines dans chaque groupe.
Le RSI est une stratégie d’achat et de vente simulée.
Définir une variable dans un tableau statistique.
Calculer le résultat du cycle en cours.
Si le cycle change et permet de négocier, la durée et les résultats de ce cycle sont enregistrés.
Si c’est la dernière ligne K et que la transaction est permise, la période et le résultat du cycle en cours sont enregistrés.
Si le cycle change et que la transaction n’est pas autorisée, la date et le résultat du cycle précédent sont enregistrés.
Trouver les résultats des cycles maximum et minimum.
Les statistiques de la peinture.
Comptez d’abord le nombre total de cycles statistiques.
Parcourir chaque cycle, colorier la tête, le temps et le résultat
Accumulation des résultats pour chaque groupe de cycle
Les résultats positifs et négatifs sont marqués par des couleurs.
Analyse des avantages
Vous pouvez voir en temps réel les résultats hebdomadaires et évaluer rapidement la performance de votre stratégie.
Une présentation intuitive des résultats, à première vue, pour identifier les périodes de mauvaise performance de la stratégie
Les paramètres de la stratégie peuvent être ajustés et optimisés en fonction des pertes et des gains de la période
Des gains cumulés sur plusieurs semaines pour une stratégie de détention à long terme
Analyse comparative des styles de négociation pour différentes périodes
Personnaliser la précision statistique et le nombre de semaines de regroupement pour répondre à des besoins différents
Le code est simple, clair, facile à comprendre et à réutiliser
Analyse des risques
Cette stratégie est basée sur le RSI pour simuler le trading, la stratégie RSI elle-même présente des inconvénients qui ne sont pas assez forts pour suivre la tendance
Dans le monde réel, les frais de transaction ont un impact plus important sur les résultats.
Les données historiques utilisées pour le suivi ne reflètent pas nécessairement les conditions de transaction réelles.
Les résultats statistiques dépendent du montant réel du compte, le montant par défaut du compte en rétrospective n’est pas forcément exact.
Attention à ne pas trop s’adapter et à ne pas modifier les paramètres de la stratégie à l’aveugle en fonction des résultats du test
Il est possible de renforcer la stratégie RSI en combinant plus d’indicateurs pour juger de la tendance et optimiser les points d’entrée et de sortie. Lorsque vous négociez en direct, veillez à régler les commissions en fonction des paramètres réels.
Direction d’optimisation
On peut envisager d’ajouter une logique de stop loss pour contrôler les pertes individuelles.
Optimiser les paramètres de la stratégie, tels que l’ajustement de la barre de décalage de la hausse et de la baisse du RSI
Vous pouvez essayer différentes fréquences de négociation, par exemple, les transactions au jour le jour ou les positions mensuelles.
Il est possible d’ajouter plus d’indicateurs pour évaluer les tendances du marché et le moment de l’entrée.
On peut envisager d’ajouter une logique de blocage.
Paramètres permettant d’optimiser les paramètres statistiques
Des statistiques sur plusieurs actifs peuvent être envisagées
L’ajout d’un stop-loss permet de mieux contrôler les risques et les ratios de rendement. L’optimisation des paramètres RSI peut améliorer le taux de victoire. L’adoption de plus d’indicateurs et de différentes fréquences de négociation peut rendre la stratégie plus stable.
Résumer
L’objectif de cette stratégie est de collecter les résultats des transactions sur une période donnée et de les afficher sous forme de tableaux statistiques, permettant ainsi de juger rapidement les pertes et les pertes de la stratégie sur différentes périodes. Cela fournit un support de données pour l’optimisation de la stratégie.
/*backtest
start: 2023-09-12 00:00:00
end: 2023-10-12 00:00:00
period: 3h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/
//@version=5
// strategy('Strategy weekly results as numbers v1', overlay=true, default_qty_type=strategy.percent_of_equity, default_qty_value=25, commission_type=strategy.commission.percent, commission_value=0.04)
after = input(title='Trade after', defval=timestamp('01 Jan 2019 00:00 UTC'), tooltip="Strategy will be executed after this timestamp. The statistic table will include only periods after this date.")
before = input(title='Trade before', defval=timestamp('31 Dec 2024 23:59 UTC'), tooltip="Strategy will be executes before this timestamp. The statistic table will include only periods before this date.")
statisticPrecision = input.int(title='Statistic precision', group='Statistic visualisation', defval=1, tooltip="Defines how many digits should be rendered in every statistic cell.")
statisticGroupSize = input.int(title='Statistic group size', group='Statistic visualisation', defval=12, tooltip="Defines how many cells should be in one group inside the statistic table.")
// determinet whether the starategy should be traded between the period
isTradeEnabled = true
// *******************************************************************************************
// Core strategy simulation logic
// *******************************************************************************************
// calculate rsi strategy emulation data
rsiEmulationData = ta.rsi(close, 7)
rsiEmulationCrossover = ta.crossover(rsiEmulationData, 70)
rsiEmulationCrossunder = ta.crossunder(rsiEmulationData, 30)
// entry loogic based on the rsi calculations
if (isTradeEnabled and rsiEmulationCrossover)
strategy.entry('Long', strategy.long)
if (isTradeEnabled and rsiEmulationCrossunder)
strategy.entry('Short', strategy.short)
// *******************************************************************************************
// Weekly statistics table
// *******************************************************************************************
// define statistic variables
var statisticTable = table(na)
var statisticPeriodTime = array.new_int(0)
var statisticPeriodResult = array.new_float(0)
var statisticIsLatestCalculated = bool(na)
var statisticResultHighest = float(na)
var statisticResultLowest = float(na)
var statisticColorGray = color.new(color.gray, transp = 60)
var statisticColorGreen = color.new(color.green, transp = 60)
var statisticColorRed = color.new(color.red, transp = 60)
// claculate current period result
barResult = not na(strategy.equity[1])
? (strategy.equity / strategy.equity[1] - 1) : 0
isPeriodChanged = not na(time[1]) and weekofyear(time) != weekofyear(time[1])
currentPeriodResult = 0.0
currentPeriodResult := not na(currentPeriodResult[1]) and not isPeriodChanged
? ((1 + currentPeriodResult[1]) * (1 + barResult) - 1) : 0.0
// initialise highest and lowest results variables
statisticResultHighest := na(statisticResultHighest) ? currentPeriodResult : statisticResultHighest
statisticResultLowest := na(statisticResultLowest) ? currentPeriodResult : statisticResultLowest
// search for highest and lowest results
statisticResultHighest := currentPeriodResult > statisticResultHighest ? currentPeriodResult : statisticResultHighest
statisticResultLowest := currentPeriodResult < statisticResultLowest ? currentPeriodResult : statisticResultLowest
// new week while trade is active
if isPeriodChanged and isTradeEnabled
timeCalculated = time - 1000 * 60 * 60 * 24 * 7
resultCalculated = currentPeriodResult[1]
statisticIsLatestCalculated := false
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// latest bar while trade is active
if barstate.islast and isTradeEnabled
timeCalculated = time - 1000 * 60 * 60 * 24 * (dayofweek(time) - 2)
resultCalculated = currentPeriodResult
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// new week after trade disabled
if isPeriodChanged and not isTradeEnabled and not na(statisticIsLatestCalculated) and not statisticIsLatestCalculated
timeCalculated = time - 1000 * 60 * 60 * 24 * (dayofweek(time) + 5)
resultCalculated = currentPeriodResult[1]
statisticIsLatestCalculated := true
array.push(statisticPeriodTime, timeCalculated)
array.push(statisticPeriodResult, resultCalculated)
// render statistics table
if barstate.islast
statisticLength = array.size(statisticPeriodResult)
statisticTableSteps = math.floor(statisticLength / statisticGroupSize) + (statisticLength % statisticGroupSize != 0 ? 1 : 0)
statisticTable := table.new(position.bottom_right, columns = statisticGroupSize + 2, rows = statisticTableSteps + 1, border_width = 1)
// render headers
for i = 0 to (statisticGroupSize - 1)
statisticHeaderContent = str.tostring(i + 1)
table.cell(statisticTable, 1 + i, 0, statisticHeaderContent, bgcolor = statisticColorGray)
// render time points
for i = 0 to (statisticTableSteps - 1)
statisticPointContent = str.format("{0,date,medium}", array.get(statisticPeriodTime, i * statisticGroupSize))
table.cell(statisticTable, 0, 1 + i, statisticPointContent, bgcolor = statisticColorGray)
// render the result
statisticResultCummulative = 0.0
for i = 0 to (array.size(statisticPeriodTime) - 1)
statisticColumn = 1 + i % statisticGroupSize
statisticRow = 1 + math.floor(i / statisticGroupSize)
statisticResult = array.get(statisticPeriodResult, i)
statisticResultCummulative := (i % statisticGroupSize == 0) ? 0.0 : statisticResultCummulative
statisticResultCummulative := (1 + statisticResultCummulative) * (1 + statisticResult) - 1
statisticResultColor = statisticResult > 0 ? statisticColorGreen : statisticColorRed
table.cell(statisticTable, statisticColumn, statisticRow, str.tostring(math.round(statisticResult * 100, statisticPrecision)), bgcolor = statisticResultColor)
// if it is the last item of the row or data array
isStatisticLastOfTheRow = ((i + 1) % statisticGroupSize) == 0
isStatisticLastOfTheData = i == (statisticLength - 1)
if (isStatisticLastOfTheRow or isStatisticLastOfTheData)
resultsTableCummulativeCellColor = statisticResultCummulative > 0 ? statisticColorGreen : statisticColorRed
resultsTableCummulativeCellContent = str.tostring(math.round(statisticResultCummulative * 100, statisticPrecision))
table.cell(statisticTable, 1 + statisticGroupSize, statisticRow, resultsTableCummulativeCellContent, bgcolor = resultsTableCummulativeCellColor)