Machine Learning with algoTraderJo

Much better! However you are still thinking as if an ensemble was a portfolio (thinking that the returns add to each other and so opposite returns would yield better results). The success of an ensemble cannot be predicted from the return series of the models (while the success of a portfolio can indeed be predicted) because in an ensemble the creation of the ensemble itself changes the distribution of returns. In an ensemble things are much more complicated because changes in signals change trading behavior as a whole. I want you guys to reach some conclusions before moving to other stuff. Chiefly I want you guys to see that an ensemble and a portfolio are very different and you cannot simply put them in the same place (use the same tools for analysis).

There is a much stronger reason why the before showed ensemble does not give good results. Think about how the two models trade and what changes when you trade in an ensemble. There is a very fundamental change in trading behavior between an ensemble and the separate models that does not happen in a portfolio. Do experiments, ask questions, I'll try to guide you as well as I can.

Things have become a bit quiet now , perhaps you are missing some information to figure out what is happening here. I will now show you another, more radical, ensemble example with some additional modifications that may shine some light into what is going on. In this case I am using 2 basic NN models, both models attempt to predict the highest/lowest excursions within the next 4 bars (these are the two output neurons) using either 100 examples and 3 bars as inputs or 50 examples and 2 bars as inputs. As always we train the models on every bar. I enter a long trade whenever the excursion to the upside is higher than the excursion predicted to the downside and vice versa. The two models have radically different results (100|3 model is much better than 50|2 model). The image I show next contains the results of the two models plus a series of ensembles and portfolio results:



We have a pure ensemble (enter only trades when both models agree, do nothing when they disagree) and a pure equally weighted portfolio. We also have two additional tests that show the results of the ensemble with additional modifications carried out to the SL on every bar if a trade is open. The "close move stop" moves the stop on every bar to the stop that the trade would have if it was a new trade (so it moves the stop 60% of the ATR20 away from the current bar open, regardless of where the stop was previously) and the "move stop only if better" only moves the stop if a stop 60% of the ATR20 away from the open is more favorable compared with the trade's current stop. This second stop is what Daniel calls an AFM-TL (Always Forward Moving Trailing Stop). Stops are only moved at the start of every daily bar.



You can see that modifying the SL improves results very significantly and in fact the ensemble "move stop only if better" has a Sharpe ratio that is higher than that of the other ensembles (by more than 20%). What does this tell you about why systems are successful and how the making of an ensemble changes trading behavior in a way that a portfolio does not? How do trade exits change from a single system to a portfolio? why is the changing of an SL so critical? How does an ensemble change the SL behavior? Remember that when we get a signal in the same direction on a model we update the SL -- This behavior is most critical. Thoughts?

The difference of a ensembles and a portfolio is that the portfolio doesn't change the trading strategy but the ensembles does it. When you have a portfolio you can combine linearly the profits of the two system because each system trade independently of the other. The ensembles is different because not only the two systems are dependent but because it change the periods in which each system trade. A good ensembles could be one that prevent us to trade in periods that the strategy is going to experiment drawdowns. I said this because ensemble 3 attempt to limit those drawdowns periods by moving the stop loss only if better. So in a pure ensemble having different signals of the models, in periods that they are going to have drawdowns, will be the best. Also I have this idea because I read something you post early in this thread:

Can you post the csv file with the ensembles returns, but from the model before this new one?

algoTraderJo,

Thank you for posting this followup. I have moved my analysis into R and now attempt to show graphically the result from my assumptions, flawed as they were. I'm hoping that this will show my reasoning and I can determine where the error in my logic lies. Note how the results (see sharpe ratios) are similar until we get to the ensembles. The first ensemble is mostly "in the ballpark". The 2nd ensemble is "not even close". I've clearly made an error in my assumptions or may be unwittingly accessing future information, or something else...

I note that the money management strategy that you use has a real impact on the sharpe ratios produced for NN1, NN2 and the portfolio in increasing, no change and decreasing slightly sharpe respectively. Without using this MM strategy, the return-based sharpe for the combined portfolio outperforms either NN1 or NN2 based on the data that I was given (which doesn't include the money management strategy).

For the first ensemble (close on disagreement), I used the following approximate code (where pos = 1 means take a position, and pos = 0 means take no position or go flat):
In other words, if the signs are opposite between the two returns (one system long, the other short), then the position is flat (0), else the pnl from the two is summed up and averaged. This set of rules seemed to come fairly close to the actual result, and also showed a lower result than the combined portfolio, but a higher result than NN2 (which is different in your results). The difficulty comes in knowing the actual positions held. I don't know if the actual position of each system is ascertainable from the information given. Sure, we can see the equity changes but it is possible that in some cases a stop loss is hit on one strategy that isn't hit on the other. In other words it seems we need the ability to infer position to correctly implement ensemble rules with any kind of accuracy - but I'm not confident that this can be accurately inferred from the equity returns alone.


The rule I used for the last ensemble (do nothing on disagreement) was as follows:
While this set of rules created a very smooth curve with the highest sharpe ratio, it is possible that it may require future knowledge to achieve. The basic idea is that if NN1 and NN2 have different positions (from the set -1, 0, 1) and the absolute value of those positions doesn't sum to zero (in other words you don't have offsetting long and short in NN1 and NN2 respectively), then take a position, else go flat.

In retrospect the rule listed above doesn't accurately represent "do nothing on disagreement". But without accurate position information, I'm not certain it is possible to represent this ensemble. If the two systems start off with the same sign in their equity returns, you can infer that they have the same position. However this could be long or short. As long as both systems have the same position sign there are no problems in implementing this. However, when the signs differ, you don't know if you should follow the losing or the winning system's results.

If the initial position for two systems starts out LL, then in the next state they are both SS, it shows up in the equity curve generally as either of the following 4 options for a two-step series for the two systems [1) profit-profit, profit-profit, 2) p-p, l-l, 3) l-l, p-p, 4) l-l, l-l].

There are too many possible choices to infer position IMO. When the equity shows loss-profit or profit-loss you can infer that the positions are different but you CANNOT know which position is correct (the same as the last position) from just the return series! The simple matter is that the positions could invert on any step, so profit could be associated with either long or short and loss could also be associated with either long or short. I feel that with only an equity return series there simply isn't enough information to create a trade series, which is needed to properly model the ensemble where the systems retain their past position on disagreement. I hope this makes sense.

Hello algoTraderJo,

I'm interested in your thread and I just started reading it. Would you please tell me what is the take-profit in your approach? You haven't mentioned it in this post.

As far as I followed this thread, here is the answer to your question with a few extra info derived from this post

1. A signal in the opposite direction means that a trade is closed and a new trade is opened in the new direction.
2. A signal in the same direction resets the stoploss as if a trade was just opened (stoploss is 60% of the ATR20)
3. A spread of 3 pips is used

I think algoTraderJo follows consistantly above rules in his experiments posted in this thread. However, he can correct me if it is not true...

@algoTraderJo: Let's assume that a LONG signal is predicted while a LONG trade is curenly open. If the new calculated stop loss yeilds to a lower stoploss level than the current stoploss level, what action do you take? (1) you modify the sl to the lower stoploss level anyway? or (2) you won't modify the stoploss level in this case? or (3) you take some other action?

Here is the result of my experiment with General Regression Neural Network (GRNN). I train the model on each bar open. A position is closed if the prediction is opposite to the current running postion, and a new position in the direction of the prediction will be opened. The current position stoploss will be modified if the prediction agrees with the current running position.

Here is the list of settings used in this experiment:

1. Input feature vector of network: [a1 v1 ... a5 v5], where a_x = (Close[x]-Open[x]) and v_x = (Volume[x]-Volume[x+1])/Volume[x+1].
2. Desired output : 1.0 if Close[x-1]<Open[x-1] and 0.0 if Close[x-1]>Open[x-1].
3. The number of traing data was set to 100.
4. If the predicted value is greater than 0.5 it is interpreted as 1.0 (SELL), otherwise 0.0 (BUY).
5. Stoploss was set to 70% of ATR(20).
6. The history is from 2010-01-01 to 2015-01-01, Daily bars.
7. The currency pair is EURUSD.
8. A fixed lot size of 0.1 was used.

The past days I have been testing as well with very mixed results. I am not quite there yet, lots of testing.
I have created SVM and NN with various settings and ran them through the different ensemble options. Parameters being
1. StopLoss - 0.5 - 2 ATR
2. Reentry after stop (true/false)
3. Ensemble - exit on disagreement (true/false)

With the input I stuck to last 4 bars return. I don't feel like my underlying NN and SVM are good enough yet. Inputs/Outputs.

I don't quite get the past few posts challenge of mathematically explaining any grouping of ensembles. IMHO it is computationally inexpensive. From all I have gathered the past few days, generating different nn/svm from different inputs takes the time, not combining them to form some ensemble or putting some money mangemement on top. It certainly makes the difference in the end, but the results of my underlying NNs need to improve first.

Cheers
KaBo

algoTraderJo,

I'll try a simpler to understand explanation that hopefully expands the discussion a bit and puts us over the finish line on the ensemble divination issue. If you have an equity curve, how do you get the position series? A formula for the equity curve or more appropriately due to the data given from NN1, NN2, the equity differences could be written as follows:

From this it is fairly obvious that the position series for the sum of the systems' signals (the ensemble) can be solved if you have both the equity differences and the price differences (solving for 1 unknown).

In the data that was provided, the equity differences for both NN1 and NN2 were provided. Also given the price series, the positions of both NN1 and NN2 could be determined. From this data it would be fairly straightforward to reproduce both types of ensembles because you would know the positions for each system at each step.

But after all this I have to wonder if this gets us anywhere beyond simply applying the ensemble to the data? Maybe this is just a thought exercise? In that respect it has succeeded because I have thought about this quite a lot.

Hi algoTraderJo,

Could you provide a few more details on your neural network so I can try to reproduce your results and move this conversation forward. I'm not entirely sure what you mean by inputs using the last 3 bars of 100 examples. Does this mean you use bars at t-0, t-1, t-2 (example 1) and follow with bars t-1, t-2, t-3 (example 2 ) etc? What inputs are you using, is it the change in pips per day, or change in percent or some other set of input numbers? I assume that you normalise all your inputs between -1 and 1? And lastly, how many hidden layers are you using and hoe many nodes are in each layer? From this I should be able to get within the same ballpark as your figures...

@beachloup:

Thanks for piping up to keep the thread running. I have been following it with interest too. The following quote from AlgoTraderJo may give you what you need (See page 13) :

PM.

This is why I dislike NNs. How many inputs? How many hidden layers? How many neurons in each layer? Which activation function to use (You may have a different one in each layer and even in each neuron)? How are the neurons linked to each others (topology of the net)? How many iterations? How small the convergence threshold?

So many degrees of freedom! And they are only tuned by hand through trail and error. The best way to overfit the dataset IMO. Because the adjustement of these hyper parameters are tweaked manually looking at the overall equity curve result it makes no difference that the NN is retrained every N bars (How many btw? One more DoF).

Hi pipMeUp:

Yes, I agree they are awkward. But if they are kept simple they are manageable. In this case, for instance, don't worry about topology, just use the one described by Algo. And use the same activation functions. As a rule, NN's work best with the fewest layers and fewest nodes/layer that will train. As you have pointed out, this requires trial and error but the number of nodes in the input layer is completely constrained as is the number in the output layer. That only leaves the hidden layers, of which one is usually sufficient. And a good first stab a the node count for the hidden layer is sqrt((Ni * Ni) +( No * No)) where Ni is input node count and No is output node count. Also, many NN packages have defaults for topologies and activation functions that work well out-of-the-box.

Are you using one right now? I'm using the AMORE NN package for R.

PM.

I know there are rules of thumb. But they are just that: rules of thumb. You can keep your NN manageable but I needn't a manageable NN I need a NN that learns and generalizes in the most efficient manner. You know Einstein's "as simple as possible but not simpler".

So no I'm not using any NN package because I'm still not convinced that it really works. For instance you say to use the same activation functions as ATJo does. But why is he using this one? Simply because he tried all of the available ones in his framework and this one gave the best results. That's already data snooping to me!

Sure enough it is impossible to infer everything from the data, especially when the SNR is as bad as in financial time series but I'd like more autonomy from the learning algo. I tried Gaussian Processes on toy examples and already they require a lot of help from the user. SVM are even worse (but much faster).

(I don't understand why the input layer is constrainted. I can use any number of past values to form the input sample.)

fromPipMeUp : (I don't understand why the input layer is constrainted. I can use any number of past values to form the input sample.)

You're right, but what I mean is the number of inputs is constrained by the number of training features (past values) you want to use. And that has nothing to do specifically with NNs. Regardless of the pattern recognition method one uses, the user must determine how many inputs to use based on the model to be fitted. Once one has decided on an appropriate model, the input layer size is fixed.

PM.

PipMeUp

did you tried extreme learning machines
http://www.ntu.edu.sg/home/egbhuang/pdf/ELM-NC-2006.pdf

its a NN with only one huge hidden layer composed of random defined neurons

there is no backpropag because you just adjust the final layers weight which can be dopne by matrix resolution

for me its rather similar to genetic algo NN

anyway i am lazy so i only use genetic algo NN
amazon ec2 to the rescue for computing power

Thanks Felixis. I read their paper and it is a big improvement in NN development. Looks like it simplifies training too. Do you have source code for their method? I code in Delphi (objective pascal) but I can read C and C++. I would really like to implement their method.

PM.

http://www.ntu.edu.sg/home/egbhuang/elm_codes.html

thx PipMemUp for giving the fundamental reference

the C++ seems to use a lot of mathlab codes

I dont know if you use this
the primary thing is that the ouput weights combine linearly
this thing is a kind of smooth hashing by random features

as for the similarty to the brain, true that randomness seems important (or maybe a goog coding entropy) maybe for low levels
but for higher levels i personnaly think that the brain generates hypothesis rather than react and train a NN

for a simple article about this in julia programming language with library
http://lepisma.svbtle.com/extreme-le...nes-with-julia

No I don't use this. Before your post I didn't know it existed ;-)

I downloaded the java version and tried with a toy example: using 100 samples I make it learn if a 2D point is above or below a
function. For each sample in the training set there 5% chance I mislabel them.

In the images, the land of the Green is above the function. Below is the land of the Red. The blue line is the frontier function.
The red dots are the samples labelled red. The samples labelled green are in yellow (in green you can't see them).
The function used is f(x) = 0.6 - 1.7 * (x - 0.4) * (x - 0.1) + 0.2 * Math.sin(17 * x)

Here is a result with an ELM with 20 hiddens neurons. Each run gives a different result. For this toy example I use a Radial Basis Function as activation function which is better suited in this context. The sigmoid gives pretty much the same kind of result.


For comparison here is the result with Gaussian Processes. The image on the right is the variance map (brighter=more confidence)



Because the ELM trains and test super fast and the initial matrix is random it might be interesting to use a GA. The DNA being the random matrix.