[Python] Versuchen Sie, die FX-Systolenparameter durch zufällige Suche zu optimieren

FX Systre Parameteroptimierung in Python Also habe ich alle Parameterkombinationen des Handelssystems ausprobiert, um die optimale Lösung zu finden.

Wenn die Anzahl der Kombinationen klein ist, gibt es kein Problem mit Round-Robin, aber wenn die Anzahl der Kombinationen groß ist, wird es ziemlich schwierig. Der Optimierungsalgorithmus dafür ist [Metahuristics](https://ja.wikipedia.org/wiki/%E3%83%A1%E3%82%BF%E3%83%92%E3%83%A5% E3% 83% BC% E3% 83% AA% E3% 82% B9% E3% 83% 86% E3% 82% A3% E3% 82% AF% E3% 82% B9). Ich wollte einen bekannten genetischen Algorithmus implementieren, habe aber vorher eine einfachere Zufallssuche in Python geschrieben.

Vorbereitung

Setzen Sie die Funktion zum Konvertieren von 1-Minuten-Daten in einen anderen Zeitrahmen und die technische Indexfunktion in Indikatoren.py sowie den vorherigen Backtest und die Funktion zum Auswerten in backtest.py. Die Quelle finden Sie unter GitHub. Der folgende Code erstellt 1-Stunden-Daten in ohlc.

import numpy as np
import pandas as pd
import indicators as ind #indicators.Import von py
from backtest import Backtest,BacktestReport

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

Handelssystemparameter zur Optimierung

In der vorherigen Optimierung haben wir optimiert, indem wir zwei Parameter innerhalb eines bestimmten Bereichs wie folgt geändert haben.

SlowMAperiod = np.arange(10, 61) #Bereich der langfristigen gleitenden Durchschnittsperiode
FastMAperiod = np.arange(5, 31)  #Bereich des kurzfristigen gleitenden Durchschnittszeitraums

Bei dieser Rate gibt es nur 1066 Möglichkeiten, aber ich werde die Anzahl der Kombinationen später ändern.

Zufällige Suche

Bei einer einfachen Zufallssuche sollten Parameterwerte nacheinander zufällig generiert und derjenige mit der höchsten Backtest-Bewertung übernommen werden, hier jedoch einmal, damit er auf genetische Algorithmen angewendet werden kann. Ich habe ungefähr 20 Parameterkombinationen in jeder Generation ausprobiert und versucht, sie für mehrere Generationen zu wiederholen.

def Optimize(ohlc, SlowMAperiod, FastMAperiod):
    def shift(x, n=1): return np.concatenate((np.zeros(n), x[:-n])) #Schaltfunktion

    SlowMA = np.empty([len(SlowMAperiod), len(ohlc)]) #Langfristiger gleitender Durchschnitt
    for i in range(len(SlowMAperiod)):
        SlowMA[i] = ind.iMA(ohlc, SlowMAperiod[i])

    FastMA = np.empty([len(FastMAperiod), len(ohlc)]) #Kurzfristiger gleitender Durchschnitt
    for i in range(len(FastMAperiod)):
        FastMA[i] = ind.iMA(ohlc, FastMAperiod[i])
    
    M = 20 #Anzahl der Personen
    Eval = np.zeros([M, 6])  #Bewertungsgegenstand
    Param = np.zeros([M, 2], dtype=int) #Parameter
    RandomSearch(Param, Eval[:,0], SlowMAperiod, FastMAperiod) #Parameterinitialisierung
    gens = 0 #Anzahl der Generationen
    while gens < 100:
        for k in range(M):
            i = Param[k,0]
            j = Param[k,1]
            #Einstiegssignal kaufen
            BuyEntry = (FastMA[j] > SlowMA[i]) & (shift(FastMA[j]) <= shift(SlowMA[i]))
            #Eingangssignal verkaufen
            SellEntry = (FastMA[j] < SlowMA[i]) & (shift(FastMA[j]) >= shift(SlowMA[i]))
            #Ausgangssignal kaufen
            BuyExit = SellEntry.copy()
            #Ausgangssignal verkaufen
            SellExit = BuyEntry.copy()
            #Backtest
            Trade, PL = Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit) 
            Eval[k] = BacktestReport(Trade, PL)
        #Generationswechsel
        Param = RandomSearch(Param, Eval[:,0], SlowMAperiod, FastMAperiod)
        gens += 1
    Slow = SlowMAperiod[Param[:,0]]
    Fast = FastMAperiod[Param[:,1]]
    return pd.DataFrame({'Slow':Slow, 'Fast':Fast, 'Profit': Eval[:,0], 'Trades':Eval[:,1],
                         'Average':Eval[:,2],'PF':Eval[:,3], 'MDD':Eval[:,4], 'RF':Eval[:,5]},
                         columns=['Slow','Fast','Profit','Trades','Average','PF','MDD','RF'])

Der Unterschied zum letzten Mal besteht darin, dass wir ein Array "Param" vorbereitet haben, um die Kombination von Parametern für jede Generation zu speichern. Dann wird der Parametersatz mit dem größten Bewertungswert (in diesem Fall Gesamtgewinn / -verlust) für jede Generation gespeichert (Elite-Save), und die verbleibenden Parameter werden wiederholt zufällig generiert.

Eine Funktion, die zufällig Parameter mit Elite-Speicher generiert, kann wie folgt geschrieben werden:

#Zufällige Suche mit Elite Save
def RandomSearch(Param, Eval, SlowMAperiod, FastMAperiod):
    Param = Param[np.argsort(Eval)[::-1]] #Sortieren
    NewParam = np.vstack((np.random.randint(len(SlowMAperiod), size=len(Eval)),
                          np.random.randint(len(FastMAperiod), size=len(Eval)))).T
    NewParam[0] = Param[0] #Elite speichern
    return NewParam

Die Methode besteht darin, die Auswertungswerte zu sortieren und den 0. Parameter erneut einzustellen. Wenn Sie dies tun, erhalten Sie:

result = Optimize(ohlc, SlowMAperiod, FastMAperiod)
result.sort_values('Profit', ascending=False)

Auf diese Weise wurde nach der optimalen Lösung gesucht, aber es ist nur natürlich, dass 20 Personen seit 100 Generationen, dh fast 2000 Mal, vor Gericht gestellt wurden.

Da es diesmal nur zwei Parameter gibt, nimmt die Anzahl der Kombinationen nicht so stark zu,

SlowMAperiod = np.arange(10, 161) #Bereich der langfristigen gleitenden Durchschnittsperiode
FastMAperiod = np.arange(5, 131)  #Bereich des kurzfristigen gleitenden Durchschnittszeitraums

Erhöhen wir es auf 19.026 Möglichkeiten. Ergebnis ist