Tool zur dynamischen Strategieanalyse
ChaoZhang
Überblick
Die Hauptidee dieser Strategie ist es, den Handel in Echtzeit zu simulieren, wöchentliche Transaktionsdaten zu sammeln und die statistischen Ergebnisse in Form von Tabellen zu präsentieren, um die Performance der Strategie intuitiver zu betrachten. Es hilft uns, die Verluste der Strategie schnell zu bewerten und die Zeiträume zu identifizieren, in denen die Strategie nicht gut funktioniert, um die Strategie entsprechend anzupassen und zu optimieren.
Strategieprinzip
Setzen Sie die Anfangs- und Endzeiten der Berechnungszyklen.
Geben Sie die Genauigkeit der Statistik und die Anzahl der Wochen für jede Gruppe an.
Die RSI-Strategie ist ein simulierter Kauf- und Verkaufsschritt.
Variablen in der Tabelle definieren.
Berechnen Sie die Ergebnisse des aktuellen Zyklus.
Wenn sich ein Zyklus ändert und Handel zulässt, notieren Sie die Zeit und das Ergebnis dieses Zyklus.
Wenn es sich um die letzte K-Linie handelt und der Handel zulässig ist, wird die Zeit und das Ergebnis des aktuellen Zyklus aufgezeichnet.
Wenn sich ein Zyklus ändert und kein Handel erlaubt ist, notieren Sie die Zeit und das Ergebnis des letzten Zyklus.
Suche nach dem höchsten und niedrigsten Zyklus.
Statistiken zu Rendering.
Zuerst berechnen wir die Gesamtzahl der Zyklen.
Durchlaufen Sie jeden Zyklus, Rendieren Sie die Tabelle, die Zeit und das Ergebnis
Akkumulation für jede Gruppe von Zyklusergebnissen
Positive und negative Ergebnisse mit Farbe markiert
Analyse der Stärken
Die Strategie kann in Echtzeit die wöchentlichen Handelsergebnisse beobachten und die Strategie schnell beurteilen.
Intuitive Darstellung der Ergebnisse auf den ersten Blick, um zu erkennen, wann eine Strategie schlecht funktioniert
Strategieparameter, die je nach Zeitrahmen angepasst und optimiert werden können
Mehrwöchige Akkumulationsergebnisse einer langfristigen Positionsstrategie können bequem verfolgt werden
Vergleiche zwischen Handelsstilen in verschiedenen Zeiträumen möglich
Benutzerdefinierte statistische Genauigkeit und Anzahl der Gruppenwochen, um unterschiedliche Anforderungen zu erfüllen
Einfacher, klarer, leichter zu verstehen und zu verwenden
Risikoanalyse
Diese Strategie basiert auf dem RSI, um zu simulieren, dass die RSI-Strategie nicht stark genug ist, um dem Trend zu folgen.
In der realen Welt haben die Gebühren einen größeren Einfluss auf das Ergebnis.
Die historischen Daten, die zur Rückverfolgung verwendet werden, spiegeln nicht unbedingt die tatsächlichen Handelsbedingungen wider.
Die statistischen Ergebnisse hängen von den tatsächlichen Konten ab, wobei die Default-Zahlen in der Rückmessung nicht immer genau sind.
Vorsicht bei der Vermeidung von Überpassung und der blinden Änderung von Strategieparametern aufgrund von Rückmeldungen
Die RSI-Strategie kann durch die Kombination von mehr Indikatoren zur Beurteilung von Trends und zur Optimierung der Einstiegs- und Ausstiegspunkte verstärkt werden. Beim Handeln im realen Bereich ist es wichtig, die Gebühren nach den realen Parametern einzustellen.
Optimierungsrichtung
Es kann in Betracht gezogen werden, eine Stop-Loss-Logik einzusetzen, um einzelne Verluste zu kontrollieren.
Optimierung von Strategieparametern, wie die Anpassung des RSI an den bullish-bullish-trend
Versuchen Sie, mit einer unterschiedlichen Handelsfrequenz zu handeln, z. B. Tageshandel oder monatliche Positionen
Es gibt mehr Indikatoren, um Markttrends und Einstiegsmomente zu beurteilen.
Einfach nur zu denken über die Einführung von Stopp-Logik
Einstellungen zur Optimierung der statistischen Parameter
Erwägung der Erstellung von Statistiken über mehrere Vermögenswerte
Durch das Hinzufügen von Stop-Loss-Stopps können Risiken und Ertragsquoten besser kontrolliert werden. Die Optimierung der RSI-Parameter kann die Gewinnrate erhöhen. Die Einführung von mehr Indikatoren und einer unterschiedlichen Handelsfrequenz kann die Strategie stabiler machen.
Zusammenfassen
Der Zweck dieser Strategie ist die Sammlung von periodischen Handelsergebnissen, die in Form von statistischen Tabellen visuell dargestellt werden, um schnell zu beurteilen, wie die Strategie in verschiedenen Zeiträumen profitiert. Dies bietet eine Datenunterstützung für die Strategieoptimierung. Die Vorteile sind, dass die wöchentlichen Ergebnisse in Echtzeit angezeigt werden können, intuitiv klar und leicht zu zweimal zu entwickeln.
/*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)