Backtesting von FX Systre mit Python (2)

Backtesting FX Systre mit Python (1) Es ist eine Fortsetzung von.

Die einzigen Systeme, die in (1) zurückgetestet werden können, sind diejenigen, die den Markt zum Eröffnungspreis des nächsten Balkens für das aus dem festen Schlusskurs erzeugte Signal kaufen und verkaufen. Dieses Mal habe ich versucht, vom Limit-Handel und Open-Position-Gewinn / Verlust zum Gewinnmitnahme- und Verlustsenkungssystem zu expandieren.

Der Gesamtfluss ist der gleiche wie (1). Die gemeinsamen Teile sind kurz geschrieben. Weitere Informationen finden Sie in Artikel (1).

Erstellung von 4-Wert-Daten

Erstellen Sie EUR / USD, 1-Stunden-4-Wert-Daten für 2015 als ohlc.

import numpy as np
import pandas as pd
import indicators as ind #indicators.Import von py

dataM1 = pd.read_csv('DAT_ASCII_EURUSD_M1_2015.csv', sep=';',
                     names=('Time','Open','High','Low','Close', ''),
                     index_col='Time', parse_dates=True)
dataM1.index += pd.offsets.Hour(7) #7 Stunden Offset
ohlc = ind.TF_ohlc(dataM1, 'H') #Erstellung von Stundendaten

Kauf- und Verkaufssignale erstellen

Erstellen Sie ein Kauf- / Verkaufssignal für das System, das erneut getestet werden soll. Diesmal ist der Einstieg der Schnittpunkt des gleitenden Durchschnitts und der Ausgang der Schnittpunkt des gleitenden Durchschnitts und des Schlusskurses.

Die verwendeten technischen Indikatoren sind zwei gleitende Durchschnitte für den Eintritt und ein gleitender Durchschnitt für den Austritt.

FastMA = ind.iMA(ohlc, 10) #Kurzfristiger gleitender Durchschnitt für den Eintritt
SlowMA = ind.iMA(ohlc, 30) #Langfristiger gleitender Durchschnitt für den Eintritt
ExitMA = ind.iMA(ohlc, 5) #Gleitender Durchschnitt für den Ausstieg

Erstellen Sie mit diesen Indexwerten ein Kauf- / Verkaufssignal.

#Einstiegssignal kaufen
BuyEntry = ((FastMA > SlowMA) & (FastMA.shift() <= SlowMA.shift())).values
#Eingangssignal verkaufen
SellEntry = ((FastMA < SlowMA) & (FastMA.shift() >= SlowMA.shift())).values
#Ausgangssignal kaufen
BuyExit = ((ohlc.Close < ExitMA) & (ohlc.Close.shift() >= ExitMA.shift())).values
#Ausgangssignal verkaufen
SellExit = ((ohlc.Close > ExitMA) & (ohlc.Close.shift() <= ExitMA.shift())).values

Diese Signale werden an allen Positionen erzeugt, die die Schnittbedingungen erfüllen, aber einige werden abhängig vom Vorhandensein oder Fehlen von Positionen nicht tatsächlich übernommen. Die Steuerung wird von der folgenden Backtest-Funktion durchgeführt.

Backtest-Funktion erstellen

Dieses Mal wurden die folgenden zwei Punkte als Erweiterung der Systemhandelsregeln hinzugefügt.

1. Geben Sie einen Grenzpreis an, der zum Zeitpunkt des Eingangssignals einen bestimmten Punkt vom Preis entfernt ist, und führen Sie ihn aus, wenn der Preis erreicht ist.
2. Bereinigen Sie, wenn die geöffnete Position einen bestimmten Gewinn oder Verlust erreicht.

Daher wird das Argument der Funktion wie folgt erhöht.

def Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit, lots=0.1, spread=2, TP=0, SL=0, Limit=0, Expiration=10):

Wenn Sie hier einen positiven Wert für "Limit" einsetzen, wird ein Limitpreis angezeigt, der beim Kauf um "Limit" -Pips billiger ist, und ein Limitpreis, der beim Verkauf um "Limit" -Pips höher ist, ohne sofort beim Eingangssignal zu kaufen oder zu verkaufen. .. "Ablauf" ist die Gültigkeitsdauer des Grenzpreises und wird durch die Anzahl der Balken angegeben.

"TP" und "SL" repräsentieren Gewinn (Pips) für Gewinnmitnahmen bzw. Verlust (Pips) für Verlustreduzierung. Es funktioniert durch Zuweisen eines positiven Wertes.

Die ganze Funktion sieht so aus:

def Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit, lots=0.1, spread=2, TP=0, SL=0, Limit=0, Expiration=10):
    Open = ohlc.Open.values #Offener Preis
    Low = ohlc.Low.values #Niedriger Preis
    High = ohlc.High.values #Hoher Preis
    Point = 0.0001 #Wert von 1pip
    if(Open[0] > 50): Point = 0.01 #1 Pip-Wert des Kreuzkreises
    Spread = spread*Point #Ausbreitung
    Lots = lots*100000 #Tatsächliches Handelsvolumen
    N = len(ohlc) #FX-Datengröße
    
    LongTrade = np.zeros(N) #Handelsinformationen kaufen
    ShortTrade = np.zeros(N) #Handelsinformationen verkaufen

    #Einstiegspreis kaufen
    BuyEntryS = np.hstack((False, BuyEntry[:-1])) #Eingangssignalverschiebung kaufen
    if Limit == 0: LongTrade[BuyEntryS] = Open[BuyEntryS]+Spread #Marktkauf
    else: #Limit kaufen
        for i in range(N-Expiration):
            if BuyEntryS[i]:
                BuyLimit = Open[i]-Limit*Point #Preis begrenzen
                for j in range(Expiration):
                    if Low[i+j] <= BuyLimit: #Vertragsbedingungen
                        LongTrade[i+j] = BuyLimit+Spread
                        break
    #Ausstiegspreis kaufen
    BuyExitS = np.hstack((False, BuyExit[:-2], True)) #Ausgangssignalverschiebung kaufen
    LongTrade[BuyExitS] = -Open[BuyExitS]
    
    #Einstiegspreis verkaufen
    SellEntryS = np.hstack((False, SellEntry[:-1])) #Eingangssignalverschiebung verkaufen
    if Limit == 0: ShortTrade[SellEntryS] = Open[SellEntryS] #Marktverkauf
    else: #Beschränken Sie den Verkauf
        for i in range(N-Expiration):
            if SellEntryS[i]:
                SellLimit = Open[i]+Limit*Point #Preis begrenzen
                for j in range(Expiration):
                    if High[i+j] >= SellLimit: #Vertragsbedingungen
                        ShortTrade[i+j] = SellLimit
                        break
    #Ausstiegspreis verkaufen
    SellExitS = np.hstack((False, SellExit[:-2], True)) #Ausgangssignalverschiebung verkaufen
    ShortTrade[SellExitS] = -(Open[SellExitS]+Spread)
    
    LongPL = np.zeros(N) #Gewinn / Verlust der Kaufposition
    ShortPL = np.zeros(N) #Gewinn / Verlust der Verkaufsposition
    BuyPrice = SellPrice = 0.0 #Verkaufspreis
    
    for i in range(1,N):
        if LongTrade[i] > 0: #Einstiegssignal kaufen
            if BuyPrice == 0:
                BuyPrice = LongTrade[i]
                ShortTrade[i] = -BuyPrice #Ausgang verkaufen
            else: LongTrade[i] = 0

        if ShortTrade[i] > 0: #Eingangssignal verkaufen
            if SellPrice == 0:
                SellPrice = ShortTrade[i]
                LongTrade[i] = -SellPrice #Ausgang kaufen
            else: ShortTrade[i] = 0

        if LongTrade[i] < 0: #Ausgangssignal kaufen
            if BuyPrice != 0:
                LongPL[i] = -(BuyPrice+LongTrade[i])*Lots #Gewinn- und Verlustrechnung
                BuyPrice = 0
            else: LongTrade[i] = 0
                
        if ShortTrade[i] < 0: #Ausgangssignal verkaufen
            if SellPrice != 0:
                ShortPL[i] = (SellPrice+ShortTrade[i])*Lots #Gewinn- und Verlustrechnung
                SellPrice = 0
            else: ShortTrade[i] = 0

        if BuyPrice != 0 and SL > 0: #Abwicklung der Kaufposition durch SL
            StopPrice = BuyPrice-SL*Point
            if Low[i] <= StopPrice:
                LongTrade[i] = -StopPrice
                LongPL[i] = -(BuyPrice+LongTrade[i])*Lots #Gewinn- und Verlustrechnung
                BuyPrice = 0

        if BuyPrice != 0 and TP > 0: #Abwicklung der Kaufposition durch TP
            LimitPrice = BuyPrice+TP*Point
            if High[i] >= LimitPrice:
                LongTrade[i] = -LimitPrice
                LongPL[i] = -(BuyPrice+LongTrade[i])*Lots #Gewinn- und Verlustrechnung
                BuyPrice = 0
                
        if SellPrice != 0 and SL > 0: #Abwicklung der Verkaufsposition durch SL
            StopPrice = SellPrice+SL*Point
            if High[i]+Spread >= StopPrice:
                ShortTrade[i] = -StopPrice
                ShortPL[i] = (SellPrice+ShortTrade[i])*Lots #Gewinn- und Verlustrechnung
                SellPrice = 0

        if SellPrice != 0 and TP > 0: #Abwicklung der Verkaufsposition durch TP
            LimitPrice = SellPrice-TP*Point
            if Low[i]+Spread <= LimitPrice:
                ShortTrade[i] = -LimitPrice
                ShortPL[i] = (SellPrice+ShortTrade[i])*Lots #Gewinn- und Verlustrechnung
                SellPrice = 0
                
    return pd.DataFrame({'Long':LongTrade, 'Short':ShortTrade}, index=ohlc.index),\
            pd.DataFrame({'Long':LongPL, 'Short':ShortPL}, index=ohlc.index)

Es ist ziemlich lange her, aber um es kurz zu erklären, verarbeiten Sie das Signal zunächst wie folgt vor.

1. Verschieben Sie jedes Signal "BuyEntry", "SellEntry", "BuyExit", "SellExit" um ein Sample auf "BuyEntryS", "SellEntryS", "BuyExitS", "SellExitS". Auf diese Weise wird das Signal in der Leiste angezeigt, in der der eigentliche Kauf und Verkauf stattfindet.
2. Ersetzen Sie "LongTrade", "ShortTrade" durch den Preis, der zum Zeitpunkt des Signals gekauft oder verkauft werden soll. Der Eintrag ist eine positive Zahl, der Ausstieg ist eine negative Zahl, und beim Limit-Handel wird der Verkaufspreis an der Position des Balkens eingegeben, der während des gültigen Zeitraums zum ersten Mal den Limitpreis erreicht hat.

Drehen Sie danach die Messlatte von Anfang bis Ende und verarbeiten Sie den Kauf und Verkauf sowie die Abrechnung, während Sie das Vorhandensein der Position sowie den Gewinn und Verlust der Position überprüfen. Gibt den tatsächlich gehandelten Preis an "LongTrade", "ShortTrade" und den festen Gewinn und Verlust an "LongPL", "ShortPL" zurück.

Backtest-Ausführungsbeispiel

Das folgende Beispiel ist ein Backtest eines Systems, das zu einem Grenzpreis kauft und verkauft, der 20 Pips vom Preis zum Zeitpunkt des Eingangssignals entfernt ist und mit einem Gewinn von 100 Pips oder einem Verlust von 50 Pips getrennt vom Ausgangssignal abgerechnet wird.

Trade, PL = Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit, TP=100, SL=50, Limit=20)

Dieses Mal werde ich nur die Asset-Kurve anzeigen.

from pandas_highcharts.display import display_charts
Initial = 10000 #Anfangsvermögen
Equity = (PL.Long+PL.Short).cumsum() #Kumulierter Gewinn und Verlust
display_charts(pd.DataFrame({'Equity':Equity+Initial}), chart_type="stock", title="Asset-Kurve", figsize=(640,480), grid=True)

Der in diesem Artikel veröffentlichte Code wurde unten hochgeladen. MT5IndicatorsPy/EA_sample2.ipynb