[Python] Essayez d'optimiser les paramètres de la systole FX avec une recherche aléatoire

Optimisation des paramètres du système FX en Python J'ai donc essayé toutes les combinaisons de paramètres du système commercial pour trouver la solution optimale.

Si le nombre de combinaisons est petit, il n'y a pas de problème avec le round robin, mais si le nombre de combinaisons est grand, cela devient assez difficile. L'algorithme d'optimisation pour cela est [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). Je voulais implémenter un algorithme génétique bien connu, mais avant cela, j'ai écrit une recherche aléatoire plus simple en Python.

Préparation

Mettez la fonction pour convertir les données d'une minute en une autre période et la fonction d'index technique dans indicateurs.py, et le backtest précédent et la fonction pour l'évaluer dans backtest.py. La source peut être trouvée sur GitHub. Le code suivant créera des données d'une heure dans ʻohlc`.

import numpy as np
import pandas as pd
import indicators as ind #indicators.Importation de 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) #Décalage de 7 heures
ohlc = ind.TF_ohlc(dataM1, 'H') #Création de données horaires

Paramètres du système commercial à optimiser

Dans l'optimisation précédente, nous avons optimisé en modifiant deux paramètres dans une certaine plage comme suit.

SlowMAperiod = np.arange(10, 61) #Gamme de période moyenne mobile à long terme
FastMAperiod = np.arange(5, 31)  #Gamme de période moyenne mobile à court terme

À ce rythme, il n'y a que 1066 façons, mais je changerai le nombre de combinaisons plus tard.

Recherche aléatoire

Dans une recherche aléatoire simple, les valeurs des paramètres doivent être générées aléatoirement dans l'ordre et celle avec l'évaluation de backtest la plus élevée doit être adoptée, mais ici, une fois afin qu'elle puisse être appliquée aux algorithmes génétiques. J'ai essayé environ 20 combinaisons de paramètres dans chaque génération et essayé de le répéter pendant plusieurs générations.

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

    SlowMA = np.empty([len(SlowMAperiod), len(ohlc)]) #Moyenne mobile à long terme
    for i in range(len(SlowMAperiod)):
        SlowMA[i] = ind.iMA(ohlc, SlowMAperiod[i])

    FastMA = np.empty([len(FastMAperiod), len(ohlc)]) #Moyenne mobile à court terme
    for i in range(len(FastMAperiod)):
        FastMA[i] = ind.iMA(ohlc, FastMAperiod[i])
    
    M = 20 #Nombre d'individus
    Eval = np.zeros([M, 6])  #Élément d'évaluation
    Param = np.zeros([M, 2], dtype=int) #Paramètres
    RandomSearch(Param, Eval[:,0], SlowMAperiod, FastMAperiod) #Initialisation des paramètres
    gens = 0 #Nombre de générations
    while gens < 100:
        for k in range(M):
            i = Param[k,0]
            j = Param[k,1]
            #Acheter le signal d'entrée
            BuyEntry = (FastMA[j] > SlowMA[i]) & (shift(FastMA[j]) <= shift(SlowMA[i]))
            #Vendre un signal d'entrée
            SellEntry = (FastMA[j] < SlowMA[i]) & (shift(FastMA[j]) >= shift(SlowMA[i]))
            #Acheter un signal de sortie
            BuyExit = SellEntry.copy()
            #Vendre un signal de sortie
            SellExit = BuyEntry.copy()
            #Backtest
            Trade, PL = Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit) 
            Eval[k] = BacktestReport(Trade, PL)
        #Changement de génération
        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'])

La différence avec la dernière fois est que nous avons préparé un tableau «Param» pour stocker la combinaison de paramètres pour chaque génération. Ensuite, l'ensemble de paramètres avec la valeur d'évaluation la plus élevée (profit / perte total dans ce cas) est sauvegardé (sauvegarde élite) pour chaque génération, et les paramètres restants sont générés de manière aléatoire à plusieurs reprises.

Une fonction qui génère de manière aléatoire des paramètres avec un stockage élite peut être écrite comme suit:

#Recherche aléatoire avec sauvegarde élite
def RandomSearch(Param, Eval, SlowMAperiod, FastMAperiod):
    Param = Param[np.argsort(Eval)[::-1]] #Trier
    NewParam = np.vstack((np.random.randint(len(SlowMAperiod), size=len(Eval)),
                          np.random.randint(len(FastMAperiod), size=len(Eval)))).T
    NewParam[0] = Param[0] #Sauvegarde élite
    return NewParam

La méthode consiste à trier les valeurs d'évaluation et à redéfinir le paramètre 0. Lorsque vous faites cela, vous obtenez:

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

De cette manière, la solution optimale a été recherchée, mais elle est naturelle car nous avons essayé 20 individus pendant 100 générations, soit près de 2000 fois.

Puisqu'il n'y a que deux paramètres cette fois, le nombre de combinaisons n'augmente pas tellement,

SlowMAperiod = np.arange(10, 161) #Gamme de période moyenne mobile à long terme
FastMAperiod = np.arange(5, 131)  #Gamme de période moyenne mobile à court terme

Augmentons-le à 19 026 façons comme ça. Le résultat est