[Python] Try optimizing FX systole parameters with random search

Optimization of FX systole parameters in Python So, I tried all the combinations of parameters of the trading system to find the optimum solution.

If the number of combinations is small, brute force is fine, but if the number of combinations is large, it becomes quite difficult. The optimization algorithm for that is [Metaheuristics](https://ja.wikipedia.org/wiki/%E3%83%A1%E3%82%BF%E3%83%92%E3%83%A5% It is known as E3% 83% BC% E3% 83% AA% E3% 82% B9% E3% 83% 86% E3% 82% A3% E3% 82% AF% E3% 82% B9). I wanted to implement a well-known genetic algorithm, but before that, I wrote a simpler random search in Python.

Preparation

Put the function to convert 1-minute data to another time frame and the technical indicator function in indicators.py, and the function to perform the previous backtest and its evaluation in backtest.py. The source can be found on GitHub. The following code will create 1 hour data in ʻohlc`.

import numpy as np
import pandas as pd
import indicators as ind #indicators.Import of 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 hour offset
ohlc = ind.TF_ohlc(dataM1, 'H') #Creation of 1-hour data

Trading system parameters to optimize

In the previous optimization, we optimized by changing two parameters within a certain range as follows.

SlowMAperiod = np.arange(10, 61) #Range of long-term moving average period
FastMAperiod = np.arange(5, 31)  #Range of short-term moving averages

At this rate, there are only 1066 ways, but I will change the number of combinations later.

Random search

In a simple random search, parameter values should be randomly generated in sequence and the one with the highest backtest evaluation should be adopted, but here, one time so that it can be applied to genetic algorithms I tried about 20 parameter combinations in each generation and tried to repeat it for several generations.

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

    SlowMA = np.empty([len(SlowMAperiod), len(ohlc)]) #Long-term moving average
    for i in range(len(SlowMAperiod)):
        SlowMA[i] = ind.iMA(ohlc, SlowMAperiod[i])

    FastMA = np.empty([len(FastMAperiod), len(ohlc)]) #Short-term moving average
    for i in range(len(FastMAperiod)):
        FastMA[i] = ind.iMA(ohlc, FastMAperiod[i])
    
    M = 20 #Population
    Eval = np.zeros([M, 6])  #Evaluation item
    Param = np.zeros([M, 2], dtype=int) #Parameters
    RandomSearch(Param, Eval[:,0], SlowMAperiod, FastMAperiod) #Parameter initialization
    gens = 0 #Number of generations
    while gens < 100:
        for k in range(M):
            i = Param[k,0]
            j = Param[k,1]
            #Buy entry signal
            BuyEntry = (FastMA[j] > SlowMA[i]) & (shift(FastMA[j]) <= shift(SlowMA[i]))
            #Sell entry signal
            SellEntry = (FastMA[j] < SlowMA[i]) & (shift(FastMA[j]) >= shift(SlowMA[i]))
            #Buy exit signal
            BuyExit = SellEntry.copy()
            #Sell exit signal
            SellExit = BuyEntry.copy()
            #Backtest
            Trade, PL = Backtest(ohlc, BuyEntry, SellEntry, BuyExit, SellExit) 
            Eval[k] = BacktestReport(Trade, PL)
        #Alternation of generations
        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'])

The difference from the last time is that we prepared an array Param to store the combination of parameters in each generation. Then, the set of parameters with the highest evaluation value (total profit / loss in this case) is saved (elite save) for each generation, and the remaining parameters are randomly generated repeatedly.

A function that randomly generates parameters with elite storage can be written as:

#Random search with elite save
def RandomSearch(Param, Eval, SlowMAperiod, FastMAperiod):
    Param = Param[np.argsort(Eval)[::-1]] #sort
    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 save
    return NewParam

The method is to sort the evaluation values and set the 0th parameter again. When you do this, you get:

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

In this way, the optimal solution has been sought, but it is natural because we have tried 20 individuals for 100 generations, that is, nearly 2000 times.

Since there are only two parameters this time, the number of combinations does not increase so much,

SlowMAperiod = np.arange(10, 161) #Range of long-term moving average period
FastMAperiod = np.arange(5, 131)  #Range of short-term moving averages

Let's increase it to 19,026 ways like this. Result is