PERFORMANCE OF A NEURAL NETWORK BASED TRADING ALGORITHM IN EXTREME EVENTS

Transcription

1 ECONOPHYSICS PERFORMANCE OF A NEURAL NETWORK BASED TRADING ALGORITHM IN EXTREME EVENTS Francesco Lomio Università degli Studi di Torino July 5, 2017

2 Contents 1 Introduction Literature Review The Context Neural Networks Artificial Neural Networks Methods The Neural Network The FeedForward Backpropagation Prediction Data Manipulation Simulation Results Forecast Simulation Investment Strategy without Threshold Investment Strategy with Threshold Conclusion 25 References Appendix

3 Chapter 1 Introduction The use of algorithms in the financial markets has grown exponentially in the past years. These algorithms have become more and more complex over time, thanks to a more powerful technology and the need to keep pace with the faster trading environment. Most of the algorithms are used in order to take investment decisions based on the estimated future price of the asset. Amongst these, we can find the trend following, pair trading and High Frequency Trading algorithms, just to cite some. The most recent use another "innovative" mathematical tool: the neural networks. These are networks that model the functioning of the neurons in human brain and, if correctly implemented, after learning from past data, can be used to forecast future prices. The aim of my work is to verify is algorithm based on predictive neural network can be used, and are profitable, in period of high uncertainty, specifically during the period following the UKs EU membership referendum held on 23 June LITERATURE REVIEW With the neural networks becoming more and more common for constructing trading algorithms, a range of academic articles have been published on the subject. Unfortunately, even though its a fast-growing topic, most of the research is based on analysing how diverse types of neural network perform when forecasting financial time series. Following are some of the articles that I found useful on my research. Levendovszky and Kia [1], in their paper on Prediction Based High Frequency Trading on Financial Time Series, showed that through the use of a simple Feed-forward Neural Network, can be created an algorithm capable of forecasting financial time series and taking investment decision based on the forecasted data. Other research did the same, sometimes being able 2

4 to build algorithm with an accuracy of over 60%. Arévalo, Niño and Hermández [2], in their work on High-Frequency Trading Strategy Based on Deep Neural Network, showed that it is possible, through the use of a more complex deep neural network, build a trading algorithm which is capable of yielding 81% successful trades, with an accuracy of 66%. Due the multiplicity of neural networks available at the moment, some work has been done also in order to analyse the performances of diverse types of neural network. Guresen, Kayakutlu and Daim [3], in their paper Using Artificial Neural Network Models in Stock Market Index Prediction, compared dynamic artificial neural networks, multi-layer perceptron and hybrid networks in order to evaluate their performances in predicting stock market indices. One thing that I noticed that was missing in this work was an analysis of the performance of a neural network based trading algorithm in periods of high market uncertainty, hence the subject of my thesis. 1.2 THE CONTEXT My analysis, as said before, will be carried during a particular moment in time, the Brexit, a moment in which the markets turmoiled and experienced unexpected (and unpredicted) movements, which led the main indices as well as the currency pairs to jump minutes after the result of the referendum were announced. In particular, the GBP went down more than 10% against the USD at $1.33, a 31-year record low, as soon as the polling stations closed [4]. Figure 1.1: The USD gained 10% in the moments after the announcement of the referendum results. 3

5 1.3 NEURAL NETWORKS As said before, one of the tools used to build price forecasting trading algorithms are the Neural Networks. In the lasts years, these have become vastly used in different disciplines as an analysis and predictive tools. During my work, to build the predictive algorithm, I will use a Feed-forward neural network. Therefore, I find it useful to give a brief history and to introduce the basic and most important features of neural networks Artificial Neural Networks Neural networks models are frequently referred as Artificial Neural Networks (ANN). The models are mathematically described by a function or a distribution. In a network there are nodes, which are the biological respective are neurons, and the ANN is the function that describes the connections between the nodes. The synapses are described with the weight assigned to the connections. Lets consider the Feed Forward neural network, which is the one I used for my model. In this network, the information moves in only one direction, forward, from the input nodes, through the hidden nodes (if any) and to the output nodes. The simplest kind of neural network is a single-layer perceptron network, which consists of a single layer of output nodes; the inputs are fed directly to the outputs via a series of weights. In this way, it can be considered the simplest kind of feed-forward network. The sum of the products of the weights and the inputs is calculated in each node, and if the value is above some threshold (typically 0) the neuron fires and takes the activated value (typically 1); otherwise it takes the deactivated value (typically -1). Neurons with this kind of activation function are also called artificial neurons or linear threshold units. Figure 1.2: A visual example of Feed-forward Neural Network 4

6 A perceptron can be created using any values for the activated and deactivated states as long as the threshold value lies between the two. Most of the perceptrons have as outputs either 1 or -1 with a threshold of 0. A multi-layer neural network can compute a continuous output instead of a step function. A common choice is the so-called logistic function: f (x) = e x (1.1) The logistic function is also known as the sigmoid function. It has a continuous derivative, which allows it to be used in back-propagation. This function is also preferred because its derivative is easily calculated: f (x) = f (x)(1 f (x)) (1.2) Figure 1.3: Sigmoid Function By using the back-propagation, the output of the network is compared with the true value and an error is calculated. This error is then inserted in the network again in order to be used for adjusting the weights between the different layers, with the consequence of reducing the error at each step. After some steps (usually a large number of cycles), the error becomes constant and small enough, and therefore the network can be defined trained, meaning that it has learned a target function. One of the methods used to adjust the weights is the gradient descent optimisation. This consists on the network calculating the derivative of the function defining the error with respect to the weights themselves, and then it changes the weights in order to minimise the error. Mathematically we are trying to reach the minimum of the error function. 5

7 Chapter 2 Methods For my analysis, I chose as dataset the 10-minute price data of the currency pair USD/GBP in the year In this way, first of all I ensured to have enough data to properly train my neural network, and also, I could actually run my model on different time period in order to look for any difference in the behaviour of the model compared to when it tries to predict the price during the UK s EU membership referendum. The choice of the specific currency was driven by two major factors. First of all, the USD/GBP is one of the most traded and most liquid currency pair in the market. The second choice would have been the EUR/GBP pair, but I decided to not go on with this because of its less extreme reaction on the day following the vote. In fact, as said before, the GBP went down more than 10% against the USD Figure 10: USD/GBP exchange rate before and after the referendum, while only of 7% against the EUR. I found it more useful to test the algorithm against a 10% sudden price change than a 7% one. All the data used to run my model were downloaded from the Bloomberg Terminal present at the ESCP Europe Paris Campus. The model I used can be divided in 3 parts: the neural network[5], the dataset manipulation, the simulation. In the following sections we will see how each part is made and what specifically does. 2.1 THE NEURAL NETWORK The first step in building the neural network was to define the parameters characterising it, as shown in the script below: class MLP_NeuralNetwork( object ) : 6

8 def init ( self, input, hidden, output, iterations, learning_rate, momentum, rate_decay ) : " " " : param input : number of input neurons : param hidden : number of hidden neurons : param output : number of output neurons " " " # i n i t i a l i z e parameters s e l f. i t e r a t i o n s = i t e r a t i o n s s e l f. learning_rate = learning_rate s e l f.momentum = momentum s e l f. rate_decay = rate_decay As we can see, the neural network is described by different parameters which are later initialised. Let s see more in details: input layer: number of nodes in the input layer, which is set equal to the number of data it uses to predict the following; hidden layer: number of nodes in the hidden layer, which is arbitrary, usually between the number of input and output nodes, but in general given by trial and error; output layer: number of nodes in the output layer, which is given by the number of data I want to predict; iteration: it gives the number of times the neural network iterates the same calculation in order to better adjust the weights to minimise the error; learning rate: it indicates how fast the neural network is capable of updating itself during the various iterations; momentum: it s a term between 0 and 1 which indicates the dimension of the step that the neural network takes iterating to adjust its weights; rate decay: it s a term which helps avoiding overtraing the network by slightly reducing the learning rate over time The FeedForward This part of the algorithm, once taken the input, feed it forward throughout the neural network in order to loop it in all the nodes in the hidden layer. This is done in the following way: the outputs of the input layer multiplied by their weight are summed up and fed in the sigmoid activation function. 7

9 def feedforward ( self, inputs ) : " " " The feedforward algorithm loops over al l the nodes in the hidden layer and adds together al l the outputs from the input layer * their weights the output of each node i s the sigmoid function of the sum of al l inputs which i s then passed on to the next layer. " " " i f len ( inputs )!= s e l f. input 1: raise ValueError ( Wrong number of inputs ) # input activations for i in range ( s e l f. input 1) : # 1 i s to avoid the bias s e l f. ai [ i ] = inputs [ i ] # hidden activations for j in range ( s e l f. hidden ) : sum = 0.0 for i in range ( s e l f. input ) : sum += s e l f. ai [ i ] * s e l f. wi [ i ] [ j ] s e l f. ah [ j ] = tanh (sum) # output activations for k in range ( s e l f. output ) : sum = 0.0 for j in range ( s e l f. hidden ) : sum += s e l f. ah [ j ] * s e l f.wo[ j ] [ k ] s e l f. ao [ k ] = sigmoid (sum) return s e l f. ao [ : ] As we can see from the code, it simply initialise the input layer with the our input data, it than passes the information through the hidden layer. Here, the outputs of the input layer multiplied by their weight are summed up. This is then passed through the output in order to have an array of ouput data Backpropagation In order for the Neural Network to learn, it needs to iterate multiple times and, each time, it needs to update the weights in order to minimise the error on the output. In the back-propagation part of the code, the algorithm calculates the difference between the output obtained and the real output we are expecting, and propagates back this error in order to update the weights. This is done using the first derivative of the sigmoid function (formula 1.2) def backpropagate ( self, targets ) : i f len ( targets )!= s e l f. output : raise ValueError ( Wrong number of targets ) 8

10 # calculate error terms for output # the delta t e l l you which direction to change the weights output_deltas = [ 0. 0 ] * s e l f. output for k in range ( s e l f. output ) : error = ( targets [ k ] s e l f. ao [ k ] ) output_deltas [ k ] = dsigmoid ( s e l f. ao [ k ] ) * error # calculate error terms for hidden # delta t e l l s you which direction to change the weights hidden_deltas = [ 0. 0 ] * s e l f. hidden for j in range ( s e l f. hidden ) : error = 0.0 for k in range ( s e l f. output ) : error += output_deltas [ k ] * s e l f.wo[ j ] [ k ] hidden_deltas [ j ] = dtanh ( s e l f. ah [ j ] ) * error # update the weights connecting hidden to output for j in range ( s e l f. hidden ) : for k in range ( s e l f. output ) : change = output_deltas [ k ] * s e l f. ah [ j ] s e l f.wo[ j ] [ k ] = s e l f. learning_rate * change + s e l f. co [ j ] [ k ] * s e l f.momentum s e l f. co [ j ] [ k ] = change # update the weights connecting input to hidden for i in range ( s e l f. input ) : for j in range ( s e l f. hidden ) : change = hidden_deltas [ j ] * s e l f. ai [ i ] s e l f. wi [ i ] [ j ] = s e l f. learning_rate * change + s e l f. ci [ i ] [ j ] * s e l f.momentum s e l f. ci [ i ] [ j ] = change # calculate error error = 0.0 for k in range ( len ( targets ) ) : error += 0.5 * ( targets [ k ] s e l f. ao [ k ] ) ** 2 return error As we can see, it acts on two part of the network: on the output and on the hidden layer. On the output layer: calculates the difference between output value and target value; gets the derivative of the sigmoid function in order to determine how much the weights need to change; updates the weights for every node based on the learning rate and on the sigmoid derivative. For the hidden layer: 9

11 calculates the error multiplying the error found on the output layer with the respective weight; calculates the derivative of the activation function to determine how much weights need to change; changes the weights based on learning rate and derivative Prediction This is the last part of the neural network, but also its operative part of the code: it tells the algorithm which data to consider, how to calculate the error, update it and how to perform the prediction. def test ( self, patterns ) : for p in patterns : #print (p [ 1 ], >, s e l f. feedforward (p [ 0 ] ) ) with open( forecast. csv, a ) as forecast : forecast. write ( str ( s e l f. feedforward (p [ 0 ] ) ) + \n ) forecast. close ( ) #print ( s e l f. feedforward (p [ 0 ] ) ) def train ( self, patterns ) : # N: learning rate for i in range ( s e l f. i t e r a t i o n s ) : error = 0.0 for p in patterns : inputs = p[ 0 ] targets = p[ 1 ] s e l f. feedforward ( inputs ) error += s e l f. backpropagate ( targets ) with open( error. csv, a ) as e r r o r f i l e : e r r o r f i l e. write ( str ( error ) + \n ) e r r o r f i l e. close ( ) i f i % 10 == 0: print ( error %.5f % error ) # learning rate decay s e l f. learning_rate = s e l f. learning_rate * ( s e l f. learning_rate / ( s e l f. learning_rate + ( s e l f. learning_rate * s e l f. rate_decay ) ) ) def predict ( self, X) : predictions = [ ] for p in X : predictions. append( s e l f. feedforward (p) ) return predictions 10

12 2.2 DATA MANIPULATION In order to run the neural network, we first need to define and properly manipulate the dataset to make it usable for our purposes. The software uses a n 1 amount of data to predict the data in the position n. def load_data ( ) : #load the data using pandas, remove the possible duplicates ( checking the Date column), convert the data in the Date column as datetime format "YYYY MM DD hh :mm: ss " raw_data = pd. read_csv (. / Data. csv ) #dataset location clear = raw_data. drop_duplicates ( [ Date ] ) clear. to_csv (. / Data_clean. csv, index = False ) # indicate clean dataset new location data = pd. read_csv (. / Data_clean. csv ) data [ Date ] = pd. to_datetime ( data [ Date ] ) #define the period of i n t e r e s t for the analysis. period = ( :00:00, :50:00 ) mask = ( data [ Date ] >= period [ 0 ] ) & ( data [ Date ] <= period [ 1 ] ) data = data. loc [mask] data = data [ Last Price ] This part of the code, first of all reads the.csv file containing the data. The original file is a two column dataset, the first containing the date and the second column the exchange rate. What it does after this is to check for duplicates in the "Date" column and deletes the data associated with them. Once the dataset has been "clean" from duplicates, it select only the data in the time-frame specified. In order for the code to predict the data n given the n 1 data, it s been necessary to split the column of prices into subsets made of n data, built utilising a rolling window: [x 1,..., x n ],[x 2,..., x n+1 ],... (2.1) Through trial and error, I ve decided to use subsets made of n = 18 data, corresponding to 3 hours of trading activity given that each data point corresponds to 10 minutes. n = 18 new_data =[] for x in range (0, len ( data ) n) : new_data. append( data [ x : x+n ] ) # scale the data so values are between 0 and 1 data = np. array ( new_data ) a = data.min( ) #print (a) 11

13 b = data.max( ) #print (b) data = data a data = data / b # define the t e s t set " y " and the training set " data " y = data [ :, n 1:n] #print ( y ) print ( Y shape : +str ( y. shape ) ) data = data [ :, : 1 7 ] #print ( data ) print ( Data shape : +str ( data. shape ) ) # create a tuple containing the training and t e s t set in the following format [ [ [ x1, x2, x3,..., xn ], [ y1, y2,..., yn ] ],... ] out = [ ] for i in range ( data. shape [ 0 ] ) : Z = l i s t ( ( data [ i, : ]. t o l i s t ( ), y [ i ]. t o l i s t ( ) ) ) out. append(z) #print ( out ) return out The first part of this code does exactly what the formula 2.1 says. After creating the subsets, it needs to scale the data in order to have all the data between 0 and 1. To do so, through the min-max method, the code checks for the minimum and the maximum vale in the whole dataset: it subtracts the minimum from all the data and then divides these by the maximum value. Once this is done, it creates two different sets, called y and data. y contains the data n, while data the previous n-1 data. The last step is to create a tuple of the following format: [x 1,..., x n ] [[x 1,..., x n 1 ],[x n ]] (2.2) Finally, in order to run the algorithm, I used the following few lines of code: X = load_data ( ) s t a r t = timeit. default_timer ( ) #run the NN with the given paramethers NN = MLP_NeuralNetwork(17, 10, 1, iterations = 50, learning_rate = 0. 5, momentum = 0. 5, rate_decay = 0.01) NN. train (X) NN. t e s t (X) stop = timeit. default_timer ( ) print ( Run time : + str ( stop s t a r t ) ) run ( ) 12

14 To better understand the results obtained through this method, I wrote some more line of code just for me to be able to graphically show the real price movements compared to the forecasted: " " " f f i s the array containing the forecasted data, y i s the one containing the real data " " " f f = pd. read_csv ( forecast. csv, header = None) # location of the " forecast. csv " f i l e created when running the NN #print ( f f ) f f [ 0 ] = f f [ 0 ]. astype ( str ). str [1: 1] f f [ 0 ] = f f [ 0 ]. astype ( float64, raise_on_error = False ) f f = np. array ( f f ) k = len ( data ) f f = f f [ len ( f f ) k : len ( f f ) ] " " " I use a and b ( the min and max value found before ) to unscale the data in order to better visualise them " " " f f = f f *b f f = f f +a ffcsv = pd. DataFrame( f f ) f f c s v. to_csv ( forecasted +str ( period [ 0 ] ) + +str ( period [ 1 ] ) + n= +str (n)+. csv ) y = y*b y = y+a ycsv = pd. DataFrame( y ) ycsv. to_csv ( real +str ( period [ 0 ] ) + +str ( period [ 1 ] ) + n= +str (n)+. csv ) #print ( len ( f f ) ) #print ( len ( y ) ) " " " plot for the comparison of the two time s e r i e s " " " plt. plot ( f f, g, label= Forecasted ) plt. plot ( y, r, label= Real ) plt. t i t l e ( Period Considered : + period [ 0 ] + to + period [1]+ t +1h10min (n = +str (n)+ ) ) plt. legend ( ) plt. savefig ( str ( period [ 0 ] ) + +str ( period [ 1 ] ) + n= +str (n)+. png ) plt. show ( ) 2.3 SIMULATION After having obtained the data from the algorithm described above, I was able to analyse it and to run a simple simulation of an investment strategy based on the simulated data, to see if it would be profitable or not. In this strategy, I used the simulated data to decide whether to take a long or a short position. To calculate the profit, I used instead the real price. Therefore, I assigned a 1 every time that the forecasted price at time t+1 was greater than the one at time t, and a -1 in the opposite case. I applied this strategy in two different time periods: the first one was March, and I took this data as a base to understand if the simulation 13

15 worked properly or not. The second time-frame June, period highly influenced by the Brexit. " " " I create a l i s t of 1s and 1s according to the price movement of the forecasted data : i f at t+1 the value i s > than the one at t, I write 1, and vice versa " " " indicator = [ ] for j in range (0, l 1) : i f f f _ t e s t [ j +1] f f _ t e s t [ j ] >0: indicator. append( 1) e l i f f f _ t e s t [ j +1] f f _ t e s t [ j ] <0: indicator. append( 1) indicator. insert (0,1) #print ( len ( indicator ) ) " " " I do the same on the real data set, in order to check the performance of the algorithm (% of times i t got the right movement) " " " indicator_ real = [ ] for j in range (0, l 1) : i f y_test [ j +1] y_test [ j ] >0: indicator_ real. append( 1) e l i f y_test [ j +1] y_test [ j ] <=0: indicator_ real. append( 1) indicator_ real. insert ( 0, 1) This part of the code does exactly what s described above: first of all it creates an array of 1 or -1 according to the forecasted data (1 every time that the forecasted price at time t+1 was greater than the one at time t, and a -1 in the opposite case). It then does the same thing with the real data: this is useful to analyse the accuracy of the neural network in terms of price movements. In fact we can check how many times it forecasted the right price movement compared to the real data. In the following extract of the code, we can see it calculates the % returns of the real data (to calculate the profit) and, important, how it adjusts the 1 and -1 array created before in order to put a 1 every time that the return on the real data is 0. In this case I could simulated an "hold" position. " " " I create a l i s t containing the % difference between two consecutive values in the real data " " " returns = [ ] for j in range (0, l 1) : returns. append ( ( ( y_test [ j +1]) / y_test [ j ] ) 1) returns. insert (0,1) print ( len ( returns ) ) #print ( returns ) 14

16 " " " The newindicator i s an adjustment to the indicator l i s t created before, in order to insert a 1 everytime I find a 0 in the returns l i s t, so that I can ignore i t " " " newindicator = [ ] for i in range (0, len ( indicator ) 1) : # for j in range (0, len ( returns ) 1) : i f returns [ i ] == 0: newindicator. append( 1) e l i f returns [ i ]!= 0: newindicator. append( indicator [ i ] ) Let s now see the actual simulation. I supposed an investment of $1000, and built the array containing the returns for each time period. Once done, I could calculate the total profit for the time period analysed: x = 1000 # i n i t i a l investment " " " I calculate the p r o f i t and therefore the total p r o f i t " " " z = next ( i for i, v in enumerate( returns [ 1 : len ( returns ) ] ) i f v!= 0) #print ( z ) #print ( newindicator [ z +1]) #print ( returns [ z +1]) a = [ i for i in range (0, len ( newindicator ) 1) ] a [ z ] = x* newindicator [ z +1]*( returns [ z +1]) #print (a[ z ] ) for j in range ( z+1, len ( newindicator ) 1) : a [ j ] = ( ( ( a [ j 1]) * newindicator [ j +1]*(1+ returns [ j +1]) ) ) #print (a) profit=np.sum( a ) #print ( z ) #print ( p r o f i t ) for i in range (0, z+1) : a. insert ( i, x ) #print (a [ 0 ] ) #a [ z +1] = a [ z +1] + a [ z ] for i in range ( z+1, len ( a ) ) : a [ i ] = a [ i ] + a [ i 1] #print (a) t o t a l p r o f i t = ( ( x+ p r o f i t ) /x ) 1 t o t _ p r o f i t = Total p r o f i t : { percent :.4%}. format ( percent= t o t a l p r o f i t ) print ( t o t _ p r o f i t ) The last step is to check for the accuracy of the network, by calculating how many times the forecasted price movement, matched the real one: up_down = [ ] for i in range (0, l 1) : 15

17 i f indicator [ i ] == indicator_real [ i ] : up_down. append( 1) e l i f indicator [ i ]!= indicator_real [ i ] : up_down. append( 0) k = up_down. count ( 1) # print (up_down) precision = k/ len ( indicator_real ) price_movement = Price movement prediction accuracy : { percent :.2%}. format ( percent=precision ) print ( price_movement ) 16

18 Chapter 3 Results As said before, to run the algorithm I used the 10-minute exchange rate data for the USD/GBP concerning two different time periods, the one going from 1 January 2016 to the 31 March 2016, and the second going from 1 April 2016 to 30 June In this way, I was able to assure that the neural network had enough data to learn properly during the training period, before using its forecasted results for the analysis of the relevant periods (March and June respectively). The time window used is of 18 data point, corresponding to 3 hours of market price: the data from the first 2h50m have been used to predict the data corresponding to 3 hour. The parameters for the neural network have been set as follow: input layer: 17; hidden layer: 10; output layer: 1; iteration: 50; learning rate: 0.5; momentum: 0.5; NN = MLP_NeuralNetwork(17, 10, 1, iterations = 50, learning_rate = 0. 5, momentum = 0. 5, rate_decay = 0.01) NN. train (X) NN. t e s t (X) stop = timeit. default_timer ( ) print ( Run time : + str ( stop s t a r t ) ) run ( ) rate decay:

19 3.1 FORECAST In the figure 3.1 we can see the comparison between the real data (in red) and the data forecasted by the Neural Network (in green). We can see from both the graphs that the forecasted data follow the same trend shown by the real data, even though they don t overlap, meaning that the prediction didn t manage to give the exact price value, but was good enough to show the amplitude of the price movements. (a) March - n=18, data point 10m later (b) June - n=18, data point 10m later Figure 3.1: In figure (a) and (b) we can see the comparison between the real and the forecasted data for the periods of interest. Following the forecast results, I found it interesting to try to modify the time windows used to analyse the data. For this reason I run the algorithm again to test the forecasting quality for different time windows. Utilising the data of the first 2h50m (n=17), I tried to forecast the data corresponding to n=24, n=30, n=48 and n=78, corresponding respectively to 1h10m, 2h10m, 5h10m and 10h10m later. Following is the graph summing up the results of this further analysis. We can see how the forecast remains of the same quality until we use a time horizon of 3 hours. After that, as we can see from figure (c) and (d), the quality of the forecasting deteriorates. 18

20 (a) Forecast Comparison - March (b) Forecast Comparison - June Figure 3.2: The figure shows the comparison of the forecast at different time horizons. 3.2 SIMULATION After having obtained the data, with the method described in the chapter before, I performed a little simulation to check whether the forecasted data could be used as a good investment indicator. In both cases, I supposed an initial investment of 1000 USD, and then checked the evolution of this investment during the period analysed. The simulation has been performed for all the time horizons analysed, with two different assumption. The first was to simulate a long (short) position every time that the forecasted price at time t +1 was greater (less) than the price at time t. The second was to set a threshold under which not to invest, and therefore invest only when the difference between the price at time t + n and t was greater than said threshold. Of course in the latter, the number of total order is much less than the previous Investment Strategy without Threshold When simulating the investment without any threshold, meaning for each data point, a position is taken (long or short), we can see from figure 3.3 that we indeed get a higher profit when investing in normal market condition, compared to high volatile period like it was June Nevertheless, we can see that we are still making a profit in both the periods, respectively: % in March and % in June. What it is interesting to notice is the accuracy of the investment: it measures how many times the price movement prediction matched the real price movement. We can see that it is 19

21 really low in both cases, respectively 48.02% and 47.29%. This literally means that we would have had higher possibilities of making a profit by basing our decision flipping a coin. (a) March - n=18, data point 10m later (b) June - n=18, data point 10m later Figure 3.3: In figure (a) and (b) we can see the simulated profit for the months of March and June, without limit. When running the investment simulation on data forecasted in different time horizons, we can see how the simulated profit significantly changes according to the time horizon analysed. We can see for the month of March that the higher profit was achieved when the investment decision was based on the forecast of the data 2h10m later. Regarding the month of June, we have an overall better performance of the simulation, except for the 2h10m time horizon. Unfortunately, due to the high volatility experienced during June, it s hard to say which time horizon works better for it, given also that we never reach an accuracy of more than 49%. The same is valid also for the month of March: even though it broke the barrier of the 50% accuracy, it is still hard to confirm which time horizon works better, even though we got a definitely higher profit in the 2h10m time horizon. 20

22 (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 3.4: Investment simulation for the different time horizons - Period of interest: March. (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 3.5: Investment simulation for the different time horizons - Period of interest: June. 21

23 3.2.2 Investment Strategy with Threshold When we utilise a threshold, what s happening is that instead of opening a position for each data point, we wait for the percentage difference between one data point and the previous to be higher than a certain value. To do so I slightly modified the code shown in the previous chapter as follow: p = indicator1 = [ ] beg = f f _ t e s t [ 0 ] for i in range (1, l 2) : kk = ( f f _ t e s t [ i ]/ beg ) 1 #print ( kk ) i f kk >= p or kk<= p : beg = f f _ t e s t [ i ] i f kk >= p : indicator1. append( 1) e l i f kk <= p : indicator1. append( 1) else : indicator1. append( 0) indicator1. insert (0,1) Instead of checking for each data point, the code iterates until it finds a data point at time t + n which percentage difference with the data t is higher than the limit imposed. Once this is found, it gives the array created the value of 1 or -1 (respectively if it is higher or lower than the data at time t), and then it continues comparing the following data points to the one found at t + n. The limit I set for the simulation was 0.3%, simply because it was the first value at which the simulation actually opened some position. We can notice from figure 3.6 how this method affected the results: we get much higher profit for both the time period analysed. Moreover we can notice the "Total Order" count, which it s the measure of how many orders were placed during the simulation. We can see how few they are if compared to before: this may have a very high value if we consider that in the real world each transaction has a cost. 22

24 (a) March - n=18, data point 10m later (b) June - n=18, data point 10m later Figure 3.6: In figure (a) and (b) we can see the simulated profit for the months of March and June, when a limit is imposed. If we look at the effect of this method when considering different time horizons, we can see that for both the period analysed, the profit is much greater than in all the other cases, specially when considering a time horizon of 10h10m. This might be due to the fact that waiting for a "real" investment opportunity, it helps in increasing the profit generated. (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 3.7: Investment simulation for the different time horizons, with the limit - Period of interest: March. 23

25 (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 3.8: Investment simulation for the different time horizons, with the limit - Period of interest: June. 24

26 Chapter 4 Conclusion As we could see from the analysis in the chapter before, while we can still profit from a strategy of this kind, it certainly isnt a good strategy to use when extreme events happen. Moreover, in this specific case, weve seen that the accuracy of the neural network was around 50% in both the time periods analysed. This is the same as tossing a coin and deciding to open a long or short position based on the outcome of our action. Of course, this is not to be generalised, but it s an indicator that both the neural network used for predicting, as well as the investment strategy can still be improved massively. We saw, in fact, that as we slightly changed a parameter, being it the time horizon or the investment strategy, we had huge differences in the outcome. Many more trials can be done, but I guess that the best thing to do for now would be to define which methods works best in a more objective way, so that we could be sure that it would work independently from the time analysed. In the end, I can still say that, even if not in an absolute way, utilising these kind of algorithm in periods of normal market conditions, is much safer than period of high volatility as the Brexit: there it is where it can be observed the higher uncertainty in the method used, ranging from huge losses to huge profit just by changing a parameter. 25

27 References [1] K. Levendovszky, Prediction Based - high frequency trading on financial time series, Electrical Engineering and Computer Science, pp , [2] N. a. H. Arévalo, High-Frequency Trading Strategy Based on Deep Neural Networks, Research Gate, [3] K. a. D. Guresen, Using artificial neural network model in stock market index prediction, Expert System with Application, no. 38, [4] [Online]. Available: boost-by-projected-remain-win-in-eu-referendum. [5] [Online]. Adapted from the one provided on GitHub at the following address: github.com/florianmuellerklein/machine-learning/blob/master/old/backpropagationnn.py 26

28 Appendix DIFFERENT TIME HORIZON FORECASTING March (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 4.1: Comparison between the real and the forecasted data, when trying to predict at different time horizons - Period of interest: March. 27

29 June (a) n=24 - Data point 1h10m later (b) n=30 - Data point 2h10m later (c) n=48 - Data point 5h10m later (d) n=78 - Data point 10h10m later Figure 4.2: Comparison between the real and the forecasted data, when trying to predict at different time horizons - Period of interest: June. 28