Developing Trading Strategies with Genetic Algorithms

I think it's fairly clear that this raises the bar in terms of the quality of submissions to QC. The sophistication of the analysis and the approach go beyond most algorithms that are shared amongst trading communities and genuinely sets the template for an effective means to promote the on-going evolution of community driven quant trading strategies.

This algorithm represents a next-generation trading pattern super-set that is focussed on harnessing the abundance of available processing power for alpha discovery with genetic algorithms and machine learning techniques. This pattern should transfer to essentially any security and should be highly adaptable to different timescales.

@JayJayD: It might be worthwhile considering how it would be possible to extend and codify this model, so that for instance, additional indicators could be supported as well as multi-level chaining of logical operations.

It might also be helpful to outline the theoretical basis and suggested reading for this approach for anyone interested.

@JayJayD: Can't view the PDF unfortunately, I will try accessing it again later.

@James Smith: The reason I didn't use the framework yet is simply because I'm using the cloud environment on QC - don't like dealing with data warehousing issues on my local machine. Are there any plans by QC to integrate your project with cloud environment?

I should say that curiously, I developed a genetic programming framework in Java prior to joining QC. However, I was analyzing daily bars and couldn't find much alpha in that case, I expect results to be much better with intraday data.

James Smith thank you very much for your kind words, I truly appreciate it!

Respect to add more indicators, in the SetTradingRule method you can see that the number of indicators can be easily changed. In this implementation wasn’t a variable because of the difficulty of making variable the number of genes in the chromosome. But once you define your chromosome in the optimization.json in SharpNeat, you can change the number of indicators, and thus the operators.

Respect to making hierarchies of indicators, a quick way it can be implemented is through the ITechnicalIndicatorSignal implementation.

So, for example, the CrossingMovingAverages implementation send a True signal only when there is an actual crossing of MA's (as well the oscillators, this explain the low trades in the out-of-sample period), but you can easily change the GetSignal method to make more like a flag like this:

In this example a long-only CrossingMovingAverages instance will send a True signal when the fast moving average is above the slow one.

In any case the ITechnicalIndicatorSignal implementation can be as complex as you need as long as it returns a signal after an event.

Petter Hansson, the document issue is fixed, thanks for report it.

Beautiful code, Jay! and really appreciate you sharing it with us!

One question though... (and this maybe because I haven't tested the code yet and the answer could be in it already) how do you optimize the parameters? do you adjust them by manual testing? or by analyzing the historical data? Thanks!

Thank you Patrick Star!

The optimization is made by GeneticSharp, using the integration James Smith made.

Please note that the attached backtest is a hard coded realization of a strategy developed by the GA. As is explained in the text, the algorithm used in the optimization process cannot be replicated in the QC platform because of the use of DynamicExpresso.

The mechanics is as follows:

1. Every TradingRule parameters is a gene. And is feed to GeneticSharp through the optimization.json
2. The GA calls the QCAlgorithm with the genes encoded in the parameter dictionary. Here you can see how the data form the dictionary is decoded and then instantiated as a trading strategy.
3. Lean runs the QuantConnect algorithm with the parameters and returns the results to the GA.
4. Once a whole generation is evaluated, the GA estimated the next generation and the cycle continues.

In terms of hierarchies of indicator signals, my understanding is it should be possible to allow, for instance, ITradingSignal to have a reference to a child ITradingSignal instance along with a contingent switch that allows recursion into the hierarchy of indicator signals. So for instance you could have:

totalSignal =  (parentSignal = EMA(240) > α AND RSI(240) < β) AND (childSignal = EMA(60) < γ)

Structuring this using recursion means you simply need to decide whether to branch into a child before reusing all the same logic to build the descendant. I believe one of the main problems with this approach is the complexity of the resultant models.

I can code almost anything but that's not the point. The real value is in creativity and ideas.. Looking at this project gives you a freash set of ideas and a different way of thinking. So thanks to both of you Jay and James. Keep it coming!

I am still slow in using LEAN locally but I will try to get it to work and learn GenericSharp and the integration part. I will ask more questions once I'm there :)

James Smith, now I understand what you mean and yes complexity can explode. I‘m pretty sure that the chromosome represetation of framework like that should be very challenging!

Patrick Star, I’ll happy to help!

Fantastic stuff JayJayD and James. Spent half of yesterday getting Visual Studio up and running with the Genetic Sharp implementation and it works fantastically.

I only wish I didn't have to go and buy data for all my ideas I want to test.

I would have to say this is the only time I've ever wanted more than 4 cores.

One thing I'm itching to try is using different measures for fitness and seeing the results on out of sample data.

https://quantsketch.com/results_page.html#common-sense

Common Sense Ratio, Gain-to-Pain Ratio and Tail Ratio would be super interesting to play around with. I've peeked around the code and all I've managed to do so far is get lost. My C# is not strong enough.

Alright, so I've managed to figure out how to add the three ratios and use them as fitness measures. Just needed a bit of effort.

I'm not sure of the best way to share the changes to Lean, but if anyone is interested we can probably figure something out.

Tim Butler - We made all FX/CFD data free! :) 

Hey Tim Butler!

I’m so glad you find this work interesting! James made such amazing work that the GA integrations is painless.

As Jared Broad pointed out, data is not a problem. But, as you noted, one of the main drawbacks of this project is the training requirements of computational power. Is the cost of evaluating the individuals in a very realistic environment (Lean).

In every GA problem, the fitness definition is single most important definition. The indicator you mention seems pretty interesting, I’d love to see them working! Maybe you can try making some kind of weighted average between the different indicators and use it as fitness.

Hi,

When i try to run this in my live Oanda account, when i try to log in i get an error that the Oanda states are not the same. do you know where that needs to be corrected?

Ryan Brickey - Sounds like your oAuth got confused -- please write a quick email to support@quantconnect.com and we'll reset it for you. 

Hey Ryan Brickey, I wouldn’t put much expectation in this algorithm in particular, is just a proof of concept, the important thing here is the framework, not the resultant algorithm.

Hi JayJay,

Awesome framework.

I was able to run it on amazon EC2, but it consumed too much resources. I will consider other cheaper alternatives.

I did some modifications to the original TradingStrategies, like including Bollinger Bands, so I share it.

I would like to implement multiple rules, and for each rule have hierarchical operators for indicators. I improved somehow the parameters for a single rule, but not able to configure the hierarchy of operators. Please share if you have any ideas on how to configure hierarchical operators.

Of course, the modified strategy is meant to be used for educational purposes.

Thanks Erik. I was impressed by JayJayD's work on genetic programming and have started to work on my own derivation of this here:

jameschch/GeneticTreeAlgorithm

I have made substantial changes to the structure, fixed bugs and added unit tests. I have also provided support for a logical tree of operators including OR, NOT, (x OR y) etc. I have also added support for ADX and now plan to integrate your Bollinger bands code.

Forgot to add; I've also improved performance significantly.

Hey Erick,

I’m so glad you found this work interesting! I’ll check the BB implementation.

You nailed it respect to its main weakness, the expensiveness of the training. If I’d deploy something like this project I’d use DigitalOcean, the VM aren’t that fast but are cheap and reliable; and the interface takes the pain away from IaaS.