Zeitgeschrittene Pyramiden-Simple Quant-Strategie

Schriftsteller:ChaoZhang, Datum: 2023-12-27 17:39:40
Tags:

Übersicht

Diese Strategie ist eine einfache Quant-Trading-Strategie, die eine zeitgeschrittene Pyramidenbildung verwendet. Die Hauptidee besteht darin, täglich zu festen Zeiten lange Positionen zu eröffnen und für jede Position unterschiedliche Gewinn- und Stop-Loss-Level festzulegen, um eine gebündelte Gewinnnahme und einen Stop-Loss zu erzielen.

Grundsätze

Die Strategie beruht auf drei Grundlogiken:

Zeitschrittliche Pyramiden

VerwendensessionTimeDie Position Größe ist die durchschnittliche Zuweisung des maximalen Kapitals.
Vermögenswerte, für die eine Vermögensübertragung gewährt wird

Satz des entsprechenden GewinnstakeProfitund Stop-Loss-LevelstopLossfür jede geöffnete Position, so dass jede Position eine eigene Profit-taking- und Stop-Loss-Logik hat, um Batch-Ausführungen zu realisieren.
Alle Positionen schließen, wenn das Zeitfenster endet

Wählen Sie, ob alle während des Zeitfensters geöffneten Positionen am Ende des Fensters geschlossen werden sollen.

Vorteile

Die Strategie weist folgende Vorteile auf:

Diversifizierung des Risikos: Kapital gleichmäßig auf verschiedene Positionen verteilen, um den Verlust einer einzigen Position wirksam zu kontrollieren.
Verschiedene Positionen haben unabhängige Logiken, um Massenverluste zu vermeiden.
Flexible Konfigurationen, anpassbare Parameter wie maximale Pyramidenzeiten, tägliche Zeitfenster, Profit-Take/Stop-Loss-Verhältnisse usw.
Einfache und klare Logik, leicht zu verstehen.

Risiken

Es gibt auch einige Risiken:

Das Risiko, dass das gesamte Kapital feststeckt, wenn alle Positionen einen Stop-Loss auslösen, bevor sie einen Gewinn erzielen.
Es gibt keine Begrenzung für das Gesamtkapital für offene Positionen pro Tag. Bei zu vielen Positionen kann es vorkommen, dass die Kapitaltragbarkeit übersteigt, wenn auf ungewöhnliche Marktsituationen gestoßen wird.
Eine falsche Zeitfensterkonfiguration kann dazu führen, dass Handelschancen verpasst werden.

Erweiterung

Die Strategie kann in folgenden Aspekten verbessert werden:

Hinzufügen von Bedingungen für offene Positionen, die auf technischen Indikatoren basieren, um rücksichtslose Pyramiden zu vermeiden.
Zusätzliche Tageskapitalgrenze für die Gesamtzahl der offenen Positionen, um eine Überschreitung der Kapitaltragbarkeit zu vermeiden.
Für verschiedene Positionen unterschiedliche Gewinn-/Stopp-Verlust-Verhältnisse festlegen, um differenzierte Gewinn- und Stopp-Verluste zu erzielen.
Hinzufügen von Logiken zur Verknüpfung des Positionsbetrags mit dem Kapitalpoolsaldo.

Schlussfolgerung

Zusammenfassend ist dies eine sehr einfache Quant-Handelsstrategie-Vorlage, die die zeitgeschrittene Pyramiden-Methode verwendet. Die Logik ist einfach und klar, während es auch einige Risiken und Verbesserungsmöglichkeiten gibt. Entwickler können sie richtig optimieren, um sie zu einer relativ stabilen und zuverlässigen Quant-Strategie zu machen.

/*backtest
start: 2022-12-20 00:00:00
end: 2023-12-26 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// © A3Sh

//@version=5
strategy("Simple_Pyramiding", overlay=true, pyramiding=99, initial_capital=500, default_qty_type=strategy.percent_of_equity, commission_type=strategy.commission.percent, commission_value=0.075, close_entries_rule='FIFO')

// Study of a Simple DCA strategy that opens a position every day at a specified time.
// A position is opened at the start time of the Timeframe.
// Positions exit individually when the take profit level is triggered.
// Option to activate Stop Loss and/or Position exit at the end of the Timeframe


// Backtest Window
start_time   = input(defval=timestamp("01 April 2021 20:00"), group = "Backtest Window", title="Start Time")
end_time     = input(defval=timestamp("01 Aug 2022 20:00"),  group = "Backtest Window", title="End Time")
window() => true


// Inputs
posCount     = input.int    (6,           group = "Risk",         title = "Max Amount of DCA Entries")
takeProfit   = input.float  (2.5,         group = "Risk",         title = "Take Profit %")
slSwitch     = input.bool   (true,        group = "Risk",         title = "Activate Stop Loss")
stopLoss     = input.float  (9,           group = "Risk",         title = "Stop Loss %")
sessionTime =  input("1800-1700", group = "DCA Settings", title = "DCA Order Timeframe", tooltip="Open order at the start/If ativated, close order at the end")
exitDCA     =  input.bool   (false,       group = "DCA Settings", title = "Exit DCA Entry at end of Timeframe")


// Order size based on max amount of pyramid orders
q = (strategy.equity  / posCount) / open


// Timeframe for opening and closing a DCA order
// example taken from https://stackoverflow.com/questions/69230164/pinescript-basic-question-open-a-trade-at-a-set-time-each-day
t       = time("D", sessionTime)
isStart = na(t[1]) and not na(t) or t[1] < t
isEnd   = na(t) and not na(t[1]) or t[1] < t
bgcolor(t ? color.new(color.blue,95) : na, title = " TimeFrame Color")


// Create DCA Entries
entry_price = 0.0
if isStart and window() 
    for i = 0 to strategy.opentrades
        if strategy.opentrades == i
            entry_price := close
            entry_id = "PE_" + str.tostring(i + 1) 
            strategy.entry(id = entry_id, direction=strategy.long, limit=entry_price, qty=q)
        if strategy.opentrades == posCount
            break
            
 
//Exit DCA Entries when take profit or stop loss is triggered
if strategy.opentrades > 0 and window() 
    for i = 0 to strategy.opentrades 
        exit_from = "PE_" + str.tostring(i + 1)
        exit_id = "Exit_" + str.tostring(i + 1)
        strategy.exit(id= exit_id, from_entry= exit_from, profit = close * takeProfit / 100 / syminfo.mintick, loss = slSwitch ? close * stopLoss /100 / syminfo.mintick :na)
        

//Exit DCA Entries at end of DCA Timeframe
if strategy.opentrades > 0 and exitDCA and isEnd and window() 
    for i = 0 to strategy.opentrades 
        exit_from = "PE_" + str.tostring(i + 1)
        exit_id = "Exit_" + str.tostring(i + 1)
        strategy.exit(id= exit_id, from_entry= exit_from, stop = close)

Mehr