This is the second article in a two-part series where I discuss the top three pitfalls when backtesting Stock & ETF trading systems. In the first article, The Top Three Pitfalls of Stock and ETF System Development, I highlighted the top three issues system developers face. In this article, I'm going to show you how I fixed this problem to give me precise and accurate historical backtested results.

As many of you know, I designed the ETF trading strategies for Tuttle Tactical Management. This firm manages over $200 million in ETFs. I started working with Tuttle in 2007. One of the reasons why I was hired as a consultant was due to my expertise in developing realistic equity backtests. Being aware of the glaring issues of backtesting both Stock and ETFs with traditional trading platforms was the only thing I could do to fix the issue. I created a system development platform that fixes these issues.

Behold! The Secret Weapon: TradersStudio
​
​The platform  developed  was TradersStudio 1.0 way back in 2003-2004. I improved the algorithm in 2005 and it has remained the same since. My algorithm requires three different types of data streams for each equity being traded. In order to generate realistic results, TradersStudio needs split-adjusted data. Many data vendors roll split and dividend-adjusted data into one series. This is not an ideal solution as on longer historical data series it just compounds the errors in precision of the split-adjusted data.

Next, TradersStudio uses dividend-only adjusted data. This simply means the data series is subtracting out the dividends without any further adjustments. CSI Data is the only vendor which allows you to produce this series because it, in effect, gives away the stock and ETF dividend database. Finally, TradersStudio needs the totally unadjusted data series. I then use my algorithm which allows me to accurately backtest portfolios of stocks and ETFs with any money management strategy you would like and get accurate results. One can see the splits and the dividends in the trade-by-trade reports along with real prices.

TradersStudio is the only product on the market that can produce a table of stock splits and dividends when CSI stock data or data from another vendor allows the data to be outputted in the correct format. Let’s look at the poster child for problems with splits and dividends, Microsoft. This analysis is shown in the splits and dividends report.

This report shows the date of splits and dividends. The number of shares (288) was calculated by multiplying the stock split ratios (2.0 * 2.0 * 1.5 * 2.0 * …). From this report we can also see that Microsoft did not pay dividends until February 19, 2003. This is a valuable report due to the fact that it allows us to audit our testing results to see what has happened. This report is also created when this type of analysis is performed on a portfolio of stocks. For example, if it were run on the S&P500 or NASDAQ 100, you would have this same report, ordered by date, for all stocks included in the portfolio.

Consider now the buy-and-hold calculation. Since the split factor for Microsoft is 288, our formula is (288 * (final price – original split price)).

 Since there are issues with “maxbars” back, we need to use the value of the first bar’s open split adjusted price on 4/25/1986. That price was $0.11111. This is “Maxbarsback + 2” bars.  Next we have our final closing price which is $46.29. This is “lastbar - 1” close on 7/29/2015.

288 * ($46.29 [final price]) - $0.11111 [split adjusted open first bar] = $13,299.52

In our buy-and-hold calculation, we also need to adjust for dividends. Since Microsoft had split 288-1 by the time it paid any dividends and has not split during the dividend period, our calculation is easy. Simply add the dividends from the Splits and Dividends report at $10.28 per share and multiply that value by 288. This gives a total of $2,960.64. Add the two numbers together and we get $16,260.16 which matches exactly what is returned on the summary report as the buy-and-hold return.

A TradersStudio stock session has two different Trade-by-Trade Reports. There is the standard report that shows the entry and exit prices with the split-adjusted values. The P/L (profit/loss) from the trade does not represent the P/L that would be calculated by only using split-adjusted data, but the real P/L on the trade. The standard Trade-by-Trade Report used to the entry and exit prices match the prices you see on the chart. The Trade-by-Trade Real Price gives you real-world results. First, let’s look at the standard report. The split-adjusted price of Microsoft is less than $0.12 on June 5, 1986 while the real price is $34!

The other report is the Trade-by-Trade Real Price Report which shows the real entry and exit prices. For example, on June 5, 1986, Microsoft was purchased at $34.25 and exited at $33.75 on June 6, 1986.

This demonstrates how buy-and-hold is calculated and how TradersStudio gives you actual entry and exit prices as well as a Splits and Dividend history. There is a problem inherent in this analysis and it’s the reason why it looks like we only made a very small percentage of buy-and-hold with this system (only 376.99 points when buy-and-hold was over $16,000).

The answer is that we should be buying the current number of shares that one original share has become and not just one share to be consistent in our first test. The size of what we are buying should be equal to the current split factor.

To do this, we need to modify our simple system by adding a call to split factor to use for sizing and a flag so that buy-and-hold still represents starting with one share when we started. The code appears as follows.

'Simple ORB system to trade stocks, backtest adjusted for
'splits to create correct comparison to buy and hold
Sub QQQBreakOutStockTest(MULT)
Dim AveTr
Dim Nxtopen
Dim NumLots
NumLots = splitfactor
BuyAndHoldSingle = true
If BarNumber < LastBar Then Nxtopen = NextOpen(0) Else Nxtopen = 0 End If If Close > Open Then
Sell("SellBrk",NumLots,Nxtopen – MULT * TrueRange,Stop,Day)
End If
If Close < Open Then
Buy("BuyBrk",NumLots,Nxtopen + MULT * TrueRange,Stop,Day)
End If
End Substocks 

backtest adjusted for splits to create correct comparison ' to buy-and-hold
Sub QQQBreakOutStockTest(MULT)
Dim AveTr
Dim Nxtopen
Dim NumLots
NumLots = splitfactor
BuyAndHoldSingle = true
If BarNumber < LastBar Then Nxtopen = NextOpen(0) Else Nxtopen = 0 End If If Close > Open Then Sell("SellBrk",NumLots,Nxtopen – MULT * TrueRange,Stop,Day)
End If
If Close < Open Then
Buy("BuyBrk",NumLots,Nxtopen + MULT * TrueRange,Stop,Day)
End If
End Sub

A new function called “splitfactor” is called. This number represents the number of shares that our original single share of stock has become after multiple splits. There is also a flag called “BuyAndHoldSingle” which is set to true. This bases buy- and-hold analysis on one original share and not the original number of shares that were purchased. For example if our analysis was started with 100 shares, buy-and- hold would be calculated based on 100 original shares if “BuyAndHoldSingle” was set to false. This means that the number of shares of Microsoft to buy and sell will change when there are signals based on the following schedule. Before September 21, 1987, only one share would be purchased.

By making this significant change, the analysis is now correctly comparing apples to apples and we see how the QQQBreakout system has done.

Indeed, our original system which looked like a joke $376.99 points versus over $16k now looks more respectable at $8,651.23 which is a little more than half of buy-and-hold. I am not arguing that this is a good system, but you can see how ensuring that we are truly comparing apples to apples which can change a system that looks dismal at first to something that actually makes sense.

When working with a stock database, the calculations should be to 4 decimal places including the time before decimalization to increase accuracy. Some stock database vendors have maintained their database calculations at only two decimal places even after decimalization occurred. This oversight serves to destroy the accuracy of the data. Using CSI Data avoids this issue entirely as they have done a good job overall of maintaining their data accurately. The purpose of this example was not to give out a great system but to illustrate and explain the issues that are related to trading stocks with stock splits and dividends. 

Learn more about this amazing platform by visiting TradersStudio.com

If you’re interested in using artificial neural networks (ANNs) for algorithmic trading, but don’t know where to start, then this article is for you. Normally if you want to learn about neural networks, you need to be reasonably well versed in matrix and vector operations – the world of linear algebra. This article is different. I’ve attempted to provide a starting point that doesn’t involve any linear algebra and have deliberately left out all references to vectors and matrices. If you’re not strong on linear algebra, but are curious about neural networks, then I think you’ll enjoy this introduction. In addition, if you decide to take your study of neural networks further, when you do inevitably start using linear algebra, it will probably make a lot more sense as you’ll have something of head start.

The best place to start learning about neural networks is the perceptron. The perceptron is the simplest possible artificial neural network, consisting of just a single neuron and capable of learning a certain class of binary classification problems. Perceptrons are the perfect introduction to ANNs and if you can understand how they work, the leap to more complex networks and their attendant issues will not be nearly as far. So we will explore their history, what they do, how they learn, where they fail. We’ll build our own perceptron from scratch and train it to perform different classification tasks which will provide insight into where they can perform well, and where they are hopelessly outgunned. Lastly, we’ll explore one way we might apply a perceptron in a trading system.

A Brief History of the Perceptron

The perceptron has a long history, dating back to at least the mid 1950s. Following its discovery, the New York Times ran an article that claimed that the perceptron was the basis of an artificial intelligence (AI) that would be able to walk, talk, see and even demonstrate consciousness. Soon after, this was proven to be hyperbole on a staggering scale, when the perceptron was shown to be wholly incapable of classifying certain types of problems. The disillusionment that followed essentially led to the first AI winter, and since then we have seen a repeating pattern of hyperbole followed by disappointment in relation to artificial intelligence.

Still, the perceptron remains a useful tool for some classification problems and is the perfect place to start if you’re interested in learning more about neural networks. Before we demonstrate it in a trading application, let’s find out a little more about it.

Artificial Neural Networks: Modelling Nature

Algorithms modelled on biology are a fascinating area of computer science. Undoubtedly you’ve heard of the genetic algorithm, which is a powerful optimization tool modelled on evolutionary processes. Nature has been used as a model for other optimization algorithms, as well as the basis for various design innovations. In this same vein, ANNs attempt to learn relationships and patterns using a somewhat loose model of neurons in the brain. The perceptron is a model of a single neuron.

In an ANN, neurons receive a number of inputs, weight each of those inputs, sum the weights, and then transform that sum using a special function called an activation function, of which there are many possible types. The output of that activation function is then either used as the prediction (in a single neuron model) or is combined with the outputs of other neurons for further use in more complex models, which we’ll get to in another article.

Here’s a sketch of that process in an ANN consisting of a single neuron:

Here, x1, x2,etc are the inputs. b is called the bias term, think of it like the intercept term in a linear model y=mx+b. w1,w2,etc are the weights applied to each input. The neuron firstly sums the weighted inputs (and the bias term), represented by S in the sketch above. Then, S is passed to the activation function, which simply transforms S in some way. The output of the activation function, z is then the output of the neuron.

The idea behind ANNs is that by selecting good values for the weight parameters (and the bias), the ANN can model the relationships between the inputs and some target. In the sketch above, z is the ANN’s prediction of the target given the input variables.

In the sketch, we have a single neuron with four weights and a bias parameter to learn. It isn’t uncommon for modern neural networks to consist of hundreds of neurons across multiple layers, where the output of each neuron in one layer is input to all the neurons in the next layer. Such a fully connected network architecture can easily result in many thousands of weight parameters. This enables ANNs to approximate any arbitrary function, linear or nonlinear.

The perceptron consists of just a single neuron, like in our sketch above. This greatly simplifies the problem of learning the best weights, but it also has implications for the class of problems that a perceptron can solve.

The purpose of the activation function is to take the input signal (that’s the weighted sum of the inputs and the bias) and turn it into an output signal. There are many different activation functions that convert an input signal in a slightly different way, depending on the purpose of the neuron.

Recall that the perceptron is a binary classifier. That is, it predicts either one or zero, on or off, up or down, etc. It follows then that our activation function needs to convert the input signal (which can be any real-valued number) into either a one or a zero corresponding to the predicted class.

In biological terms, think of this activation function as firing (activating) the neuron (telling it to pass the signal on to the next neuron) when it returns 1, and doing nothing when it returns 0.

What sort of function accomplishes this? It’s called a step function, and its mathematical expression looks like this:

And when plotted, it looks like this:

This function then transforms any weighted sum of the inputs (S) and converts it into a binary output (either 1 or 0). The trick to making this useful is finding (learning) a set of weights, w, that lead to good predictions using this activation function.

We already know that the inputs to a neuron get multiplied by some weight value particular to each individual input. The sum of these weighted inputs is then transformed into an output via an activation function. In order to find the best values for our weights, we start by assigning them random values and then start feeding observations from our training data to the perceptron, one by one. Each output of the perceptron is compared with the actual target value for that observation, and, if the prediction was incorrect, the weights adjusted so that the prediction would have been closer to the actual target. This is repeated until the weights converge.

In perceptron learning, the weight update function is simple: when a target is misclassified, we simply take the sign of the error and then add or subtract the inputs that led to the misclassifiction to the existing weights.

If that target was -1 and we predicted 1, the error is −1−1=−2. We would then subtract each input value from the current weights (that is, wi=wi–xi). If the target was 1 and we predicted -1, the error is 1–−1=2, so then add the inputs to the current weights (that is, wi=wi+xi).

This has the effect of moving the classifier’s decision boundary (which we will see below) in the direction that would have helped it classify the last observation correctly. In this way, weights are gradually updated until they converge. Sometimes (in fact, often) we’ll need to iterate through each of our training observations more than once in order to get the weights to converge. Each sweep through the training data is called an epoch.

Implementing a Perceptron from Scratch

Next, we’ll code our own perceptron learning algorithm from scratch using R. We’ll train it to classify a subset of the iris data set.

In the full iris data set, there are three species. However, perceptrons are for binary classification (that is, for distinguishing between two possible outcomes). Therefore, for the purpose of this exercise, we remove all observations of one of the species (here, virginica), and train a perceptron to distinguish between the remaining two. We also need to convert the species classification into a binary variable: here we use 1 for the first species, and -1 for the other. Further, there are four variables in addition to the species classification: petal length, petal width, sepal length and sepal width.  For the purposes of illustration, we’ll train our perceptron using only petal length and width and drop the other two measurements. These data transformations result in the following plot of the remaining two species in the two-dimensional feature space of petal length and petal width:

The plot suggests that petal length and petal width are strong predictors of species – at least in our training data set. Can a perceptron learn to tell them apart?

Training our perceptron is simply a matter of initializing the weights (here we initialize them to zero) and then implementing the perceptron learning rule, which just updates the weights based on the error of each observation with the current weights. We do that in a for()  loop which iterates over each observation, making a prediction based on the values of petal length and petal width of each observation, calculating the error of that prediction and then updating the weights accordingly.

In this example we perform five sweeps through the entire data set, that is, we train the perceptron for five epochs. At the end of each epoch, we calculate the total number of misclassified training observations, which we hope will decrease as training progresses. Here’s the code:

We can see that it took two epochs to train the perceptron to correctly classify the entire dataset. After the first epoch, the weights hadn’t been sufficiently updated. In fact, after epoch 1, the perceptron predicted the same class for every observation! Therefore it misclassified 50 out of the 100 observations (there are 50 observations of each species in the data set). However after two epochs, the perceptron was able to correctly classify the entire data set by learning appropriate weights.

Another, perhaps more intuitive way, to view the weights that the perceptron learns is in terms of its decision boundary. In geometric terms, for the two-dimensional feature space in this example, the decision boundary is the a straight line separating the perceptron’s predictions. On one side of the line, the perceptron always predicts -1, and on the other, it always predicts 1.​

We can derive the decision boundary from the perceptron’s activation function:

The decision boundary is simply the line that defines the location of the step in the activation function. That step occurs at z=0, so our decision boundary is given by

Equivalently

which defines a straight line in x1,x2 feature space.

In our iris example, the perceptron learned the following decision boundary:

Here’s the complete code for training this perceptron and producing the plots shown above:

Congratulations! You just built and trained your first neural network.

Let’s now ask our perceptron to learn a slightly more difficult problem. Using the same iris data set, this time we remove the setosa species and train a perceptron to classify virginica and versicolor on the basis of their petal lengths and petal widths. When we plot these species in their feature space, we get this:

This looks a slightly more difficult problem, as this time the difference between the two classifications is not as clear cut. Let’s see how our perceptron performs on this data set.

This time, we introduce the concept of the learning rate, which is important to understand if you decide to pursue neural networks beyond the perceptron. The learning rate controls the speed with which weights are adjusted during training. We simply scale the adjustment by the learning rate: a high learning rate means that weights are subject to bigger adjustments. Sometimes this is a good thing, for example when the weights are far from their optimal values. But sometimes this can cause the weights to oscillate back and forth between two high-error states without ever finding a better solution. In that case, a smaller learning rate is desirable, which can be thought of as fine tuning of the weights.

Finding the best learning rate is largely a trial and error process, but a useful approach is to reduce the learning rate as training proceeds. In the example below, we do that by scaling the learning rate by the inverse of the epoch number.

Here’s a plot of our error rate after training in this manner for 400 epochs:

You can see that training proceeds much less smoothly and takes a lot longer than last time, which is a consequence of the classification problem being more difficult. Also note that the error rate is never reduced to zero, that is, the perceptron is never able to perfectly classify this data set. Here’s a plot of the decision boundary, which demonstrates where the perceptron makes the wrong predictions:

Here’s the code for this perceptron:

In the first example above, we saw that our versicolor and setosa iris species could be perfectly separated by a straight line (the decision boundary) in their feature space. Such a classification problem is said to be linearly separable and (spoiler alert) is where perceptrons excel. In the second example, we saw that versicolor and virginica were almost linearly separable, and our perceptron did a reasonable job, but could never perfectly classify the whole data set. In this next example, we’ll see how they perform on a problem that isn’t linearly separable at all.

Using the same iris data set, this time we classify our iris species as either versicolor or other (that is setosa and virginica get the same classification) on the basis of their petal lengths and petal widths. When we plot these species in their feature space, we get this:

This time, there is no straight line that can perfectly separate the two species. Let’s see how our perceptron performs now. Here’s the error rate over 400 epochs and the decision boundary:

We can see that the perceptron fails to distinguish between the two classes. This is typical of the performance of the perceptron on any problem that isn’t linearly separable. Hence my comment at the start of this unit (see footnote 2) that I’m skeptical that perceptrons can find practical application in trading. Maybe you can find a use case in trading, but even if not, they provide an excellent foundation for exploring more complex networks which can model more complex relationships.

The Zorro trading automation platform includes a flexible perceptron implementation. If you haven’t heard of Zorro, it is a fast, accurate and powerful backtesting/execution platform that abstracts a lot of tedious programming tasks so that the user is empowered to concentrate on efficient research. It uses a simple C-based scripting language that takes almost no time to learn if you already know C, and a week or two if you don’t (although of course mastery can take much longer). This makes it an excellent choice for independent traders and those getting started with algorithmic trading. While the software sacrifices little for the abstraction that enables efficient research, experienced quant developers or those with an abundance of spare time might take issue with that aspect of the software, as it’s not open source, so it isn’t for everyone. But it’s a great choice for beginners and DIY traders who maintain a day job. If you want to learn to use Zorro, even if you’re not a programmer, we can help.

Zorro’s perceptron implementation allows us to define any features we think are pertinent, and to specify any target we like, which Zorro automatically converts it to a binary variable (by default, positive values are given one class; negative values the other). After training, Zorro’s perceptron predicts either a positive or negative value corresponding to the positive and negative classes respectively.

Here’s the Zorro code for implementing a perceptron that tries to predict whether the 5-day price change in the EUR/USD exchange rate will be greater than 200 pips, based on recent returns and volatility, whose predictions are tested under a walk-forward framework:

Zorro firstly outputs a trained perceptron for predicting long and short 5-day price moves greater than 200 pips for each walk-forward period, and then tests their out-of-sample predictions.

Here’s the walk-forward equity curve of our example perceptron trading strategy:

I find this result particularly interesting because I expected the perceptron to perform poorly on market data, which I find it hard to imagine falling into the linearly separable category. However, sometimes simplicity is not a bad thing, it seems.

Conclusions

I hope this article not only whet your appetite for further exploration of neural networks, but facilitated your understanding of the basic concepts, without getting too hung up on the math.

I intended for this article to be an introduction to neural networks where the perceptron was to be nothing more than a learning aid. However, given the surprising walk-forward result from our simple trading model, I’m now going to experiment with this approach a little further. If this interests you too, some ideas you might consider include extending the backtest, experimenting with different signals and targets, testing the algorithm on other markets and of course considering data mining bias. I’d love to hear about your results in the comments.

Thanks for reading!

--by Kris Longmore from blog Robotwealth

Some trading systems have prolonged periods of winning or losing trades. Long winning streaks followed by a prolonged period of drawdown.  Wouldn't it be nice if you could minimize those long drawdown periods?

Here is one tip that might help you do that. Try applying a simple moving average to your trading system's equity curve. Then, use that as an indicator on when to stop and restart trading your system. This technique might change your trading system's performance for the better. 

​​ How to do this? Well, the moving average applied to your trading system's equity curve creates a smoothed version of your trading system's equity curve. You can now use this smoothed equity curve as a signal on when to stop or restart trading. For example, when the equity curve falls below the smoothed equity curve you can stop trading your system.  Why would you do this? Because your trading system is under performing, it's losing money. Only after the equity curve starts to climb again should you start taking your trades once again. This technique is trading the equity curve. You're making trading decisions based upon your equity curve. In essence the performance of your system is an indicator.

Trading the equity curve is like trading a basic moving average crossover system. When the fast moving average (your equity curve) crosses over the slower moving average (your smoothed equity curve) you go long (trade your system live). When the fast moving average crosses under the slower moving average you close your long trade (stop trading your live system).

In a previous article I demonstrated how to build a strategy that will trade the equity curve. That is, a strategy that will stop trading when the equity curve falls below a simple moving average. Lets look at a different technique that not many retails traders are aware of. In particular this technique is difficult to execute in EasyLanguage.

What do I want to do? I want to create a trading system that tracks multiple copies of a given system. Why would I do that? Well, while each of the strategies are copies their input values are slightly different. Thus, each version creates a slightly different trade performance. Lets look at an example to make this clear.

Lets first take a trading system to work with. Lets use the example strategy called Simple S&P. The rules are straightforward and listed below.

• If today’s close is less than the close 6 days ago, buy (enter long).
• If today’s close is greater than the close 6 days ago, sell (exit long).
• Only take trades when the closing price is above 40 period SMA

This strategy produces a the following results.

Lets now duplicate our strategy and then change the inputs slightly. Instead of a our entry lookback being six, lets reduce it by one leaving us with 5. We have created a slightly different trading system which produces different results as seen below.

Lets duplicate the original strategy again and change the inputs. Instead of a our entry lookback being six, lets increase it by one. This gives us a value of seven. We have a new strategy which produces the following results.

So, we have three different trading strategies. Each uses a different lookback value to determine when to enter a trade. 

In a traditional trading environment you might optimize a single strategy over your historical data and pick a reasonable set of input parameters. You would then trade that one system. Wouldn't t it be interesting if we could monitor the performance of each strategy variation and trade the best performing strategy in real time? In essence we want to the ability to watch a horse race and change our bet as the race race progresses. A very interesting idea! But when you start to code such a scheme, it becomes a very, very daunting process.

To pull this off we need the ability to track multiple trading systems within a given strategy. We then simply pick the best performing strategy to trade live. Simple in concept but difficult to do. Natively there is no method to accomplish this in EL. However that has changed. This tool, Equity Curve Feedback Toolkit, will allow us to do just that.

Lets create our first multi agent strategy which automatically trades the best performing strategy variation.

I coded the Simple S&P rules in EasyLanguage and tested it on the E-mini S&P futures market going back to 2000. Before going further with the demonstration let me say this: all the tests within this article are going to use the following assumptions:

• Starting account size of $25,000
• Dates tested are from 1998 through December 31, 2016
• One contract was traded for each signal
• The P&L is not accumulated to the starting equity
• No deductions for slippage and commissions
• There are no stops

There are three key things we have to do to our strategy.

First is creating a virtual backtesters to track the performance of our three different different strategies. This is accomplished by using the ECF_VirtualBackTester function included with Equity Curve Feedback Toolkit. The three lines of code to accomplish this are below.

Result = ECF_VirtualBackTester(Orders1, Trades1, True);
Result = ECF_VirtualBackTester(Orders2, Trades2, True);
Result = ECF_VirtualBackTester(Orders3, Trades3, True);

Second we now get the trades and current equity from our backtesters. The function ECF_GetEquity is getting the equity information placing it within CurrentEquityX variables and EquityX arrays. 

CurrentEquity1 = ECF_GetEquity(Orders1, Trades1, Equity1, cLongAndShort, UseOpenTrade);
CurrentEquity2 = ECF_GetEquity(Orders2, Trades2, Equity2, cLongAndShort, UseOpenTrade);
CurrentEquity2 = ECF_GetEquity(Orders3, Trades3, Equity3, cLongAndShort, UseOpenTrade);

Third, we now must determine if our strategy is trading above the equity curve. This is explained in a lot more detail within the previous article, Trading The Equity Curve & Beyond. The following lines will determine if our virtual strategies are trading above their respective equity curve.

TradeEnable1 = ECF_EquityMASignal(Orders1, Equity1, EquityMALength, cLongAndShort, UseOpenTrade);
TradeEnable2 = ECF_EquityMASignal(Orders2, Equity2, EquityMALength, cLongAndShort, UseOpenTrade);
TradeEnable3 = ECF_EquityMASignal(Orders3, Equity3, EquityMALength, cLongAndShort, UseOpenTrade);

Fourth,  we must determine which of the three simulated strategies is performing the best. This is accomplished with these lines of code.

BestSys1 = false;
BestSys2 = false;
BestSys3 = false;
If ( CurrentEquity1 > CurrentEquity2 ) and ( CurrentEquity1 > CurrentEquity3 ) and ( CurrentEquity1 > 0 ) then BestSys1 = true
else If ( CurrentEquity2 > CurrentEquity1 ) and ( CurrentEquity2 > CurrentEquity3 ) and ( CurrentEquity2 > 0 ) then BestSys2 = true
else If ( CurrentEquity3 > CurrentEquity1 ) and ( CurrentEquity3 > CurrentEquity2 ) and ( CurrentEquity3 > 0 )then BestSys3 = true;

There we have it. A single strategy which tracks the performance of three virtual strategies and only trades the best performing strategy. This all happens in real time. 

Below is a snapshot of the chart showing trades being taken by our multi-agent version of the Simple S&P strategy. You can see on the left-hand side it's trading version 2 of our strategy. Then on the right-hand side of the chart it's switch to trading version 1 of the strategy. 

Below is the performance report of our multi agent strategy.

Conclusion

This is a very simple example of a multi-agent trading strategy.  In our case, we have three similar strategies being simulated in the backtester. You can create many more virtual copies. As many as you want. You don't even have to use the same strategy. In our example we used the same strategy but changed one of the inputs. You could use different strategies to compete against each other. For example, a trend following model vs a mean reverting model.

In our example we made trading decisions based upon the equity of each system but, we could use other metrics like drawdown or average profit per trade. The options are really incredible and I hope this simple example is getting the wheels in your head turning!

What are he best practices for building such a trading model? Good question. This material is rather new to me and I would love to hear what you think. Like any tool, it can be abused. My opinion at this time is you should correctly build a single, traditional, strategy first. That is, follow all the known best practices of strategy development. Once you have a solid system only then attempt to add the tools available in Equity Curve Feedback Toolkit.

You might be wondering what inputs you should change in your strategy? Good question. I think the fewer the better. In this example I only changed one of the lookback values. I think it's probably imporant that you first estable what the stable range is for each parameter. Then use the values within that range. However like I said, this is a new area for me but it sure looks promising. 

If you want a more detailed look at building this strategy I've created a video showing you how I did it. To watch the video simply sign-up below.

In this article I am going to share with you four reasons why scalpers could be dangerous and everyone who would commit money to trade with such short-term strategies should be extremely cautious and mindful. Although potentially the shorter-term a strategy is, the more profits can be earned, and there are reasons why the real time results could differ a lot from those obtained ​in backtesting mode regardless of the trading platform ​that was used. Let's begin with the first reason:

Most Forex scalpers rely on tick occurrence in order for the signals to be generated. Their logic is based upon every market movement known (tick). The problem here is that Metatrader 4, for example, which is the most popular trading platform generates ticks in the backtester using its own algorithm based on OHLC data from lowest timeframe data available – usually M1. So, the ticks used to backtest your scalper are not “real”, they are made from MT4. This fact makes the obtained backtest results susceptible for errors and discrepancy. Personally, I have made tests running a scalper on live chart for a few days and then backtested the same system in tester on the same time span. Surprisingly the trades themselves were a lot different which led me to ponder on how real my backtested calculations are and just confirmed my knowledge that ‘ticks’ on MT4 are not real.

Slippage dependency

Since scalpers are frequent traders it is reasonable to expect that the average trade measured in pips would be very low in most cases – like 0.5-1 pips at most. Therefore any additional trading cost should be subtracted from the already low average trade. A slippage of 0.4 pip would possibly wipe out almost 80% of potential profits.

In order to be sure about the profitability, one should run the scalper on a small live account and then monitors the slippage and if there is enough profit left, then the Forex strategy could be forwarded to well-funded real account.

Spread dependency

An increased spread during important Forex news or a spread just bigger than the one used in the backtest could be another cause of eaten profits. Expecting a lot of trades to be executed during a day makes a small change in spreading a potentially big determinant of the final net result of the trading system.

Since during the backtest we could only apply fixed spread, we should be very careful in choosing a broker which have low real time spreads which in turn will allow the scalper to be profitable. Another viable option here is run the backtest with wider than normal spread in order to get conservative results.

Broker's side

The final reason why I am staying away from trading with scalpers is the fact that some brokers do not allow trading with systems which are very frequent traders. Here we are talking mostly about real extreme cases where the average length of the trade is few seconds. If a trader begins to trade with such a strategy, his account could be suspended from trading so it is imperative that if you are planning to trade a scalper you contact first the broker and explain your intent and then if everything is OK, ​proceed trading.

Summary

I have shared with you my four reasons why trading with scalping strategies could be dangerous, and the traders who want to try them should be extremely cautious. The difficulties regarding the backtest accuracy, slippage, and spread costs during the real trading and broker's unwillingness are more than enough reasons for me to stay out. I hope that I have contributed to your knowledge regarding the matter. I wish you profitable trading.

With November almost over I thought it would be a good idea to review our Market Seasonality Study. 

If you will recall, back on May 18 of this year we closed our or seasonality trade in anticipation for a traditional weak period of the stock index markets. That is, the months of May, June, July, August, September and October. So what did the market do during those months?

Below is the image of the graph were we exited back in May and where we re-entered this November.

It was up, up and away! Like anything in automated trading. Not everything works our 100%. In this case we did not lose money on a losing trade per say. Instead, we lost by not participating in the continued strong bullish movie in the stock index market.

We are now entering a traditionally strong season for the stock index market. This is a well known seasonality period. In this article I would like to take a closer look at the seasonality bias which so many investors and traders talk about. 

In the following rows I'd like to share with you three ways I use to increase my discipline which is the cornerstone of every successful trader I know. The discipline is often the missing part of many traders who try to conquer the financial markets. The below presented routines are not hard to do and they are worth every minute I am investing in them. So, let's begin with the first one:

Know your trading method well

I know from my own trading experience that the more knowledge I have about my automated Forex trading strategy, the less worried I am during the real time trading. In my opinion there is a strong correlation between my knowledge of the system, my confidence in it, and my discipline to execute and trade its signals without any second thoughts in mind.

If I know when to expect good trades to occur, how often they occur, and what their characteristics are like length, open profits left off the table, then I am prepared in my mind and I don't get caught by any surprises.

Trade with less risk per trade

Once I had a very valuable and educated in nature experience trading one system with the same settings on two different accounts. On the first one I applied a conservative Money Management (MM) rule thus allowing small account swings and more consistent and less volatile equity curve. I traded the second account with ​a lot more risk per trade than the first one. I reiterate that the system was the same settings except MM.

I have noticed over time that I was consistently getting worried about the results on the second trading account. I couldn't handle the big equity swings well, watching the charts seeing my profits or losses changing a lot over time.

Then I understood that ​aside from the trading system, the risk I am committing also have a big impact on my trading psychology, and I was way more prone to making mistakes executing my trading signals because I was emotionally burned out.

The same applies for capital which I am using for trading. If I am trading with money I cannot afford to lose, then almost instantaneously I get anxious and my thoughts start to flow toward losing and why I cannot lose my money and what I will be doing without them - a very similar juncture to the high risk per trade example.

Having an exit trading plan

No matter how good my automated trading strategy is and no matter how conservative my MM rules are, I always have an exit plan in case I ​experience big equity losses. Regardless of the reason I have prepared in my mind, a fixed percentage drop with my account which if exceeded I will just stop trading and evaluate the situation. It is important that this step is done before starting to trade real with a particular system because in the heat of the moment I know that I am ​more likely to make emotional decisions, and eventually make mistakes.

This ending point is determined based upon the system's backtesting performance so that the typical equity drop could occur without stopping too early to trade the particular system. For example, if I've known from a past performance that MaxDD is 20%, they would not stop trading the systems if I lost 10% of my account because it is natural to have bigger drops. Every time I would choose an exit point which is bigger than the MaxDD from the past.

Knowing that I have a limit of my eventual losses makes me much more confident for the future, and the confidence itself translates into better discipline of applying my trading plan rigorously.

Summary

I showed to you my personal ways to increase my discipline and emotional health during real time trading with my mechanical systems. In summary I have understood ​thru an experience that the more I am prepared, the less emotional and more disciplined I am. To understand my trading method well, risking ​a little from my account per trade and having an exit plan are my ways to cope up with the task called trading. I hope that I have contributed to your knowledge with this article. I wish you a profitable trading.

-- By Professional Trading Systems.

"Creatures", in this case =  human or algorithm executing entries and exits.

I'm not going to dive deeply into human psychology, behavior but if you spend some time studying Behavioral Finance, you'll find many real-world justifications for why certain days have certain patterns, even extracting the algorithms from the equation, the human effect upon the market, therefore the human behavior upon the market is quite easily quantifiable, and to the average investor/trader/developer, looking at days of week patterns could be something useful to help improve your outcome, without diving deep into BF.

•  Volume  (Volume Total, Up Volume, Down Volume, Volume Ratio)
•  Volatility & ATR (Total, Upward movement, Downward movement)
•  Momentum (Total, Upward movement, and Downward movement & applied to Volumes)
•  Close > open and Open > close  (Up and Down bar ratios)
•  > XValue   (XValue can be a Moving Average or historical S&R, etc. Ex: Close > Lowest(high,20)[20])

Ex: ​Majority of humans, despise getting up early on Monday to go to work ​right away after they came home from a long weekend at camp... or the beach... or the ball game. So Mondays, start slow for you, until you get back in the "groove" of your work week... which could be after the ​second or third cup of Joe, which would lower the number of Discretionary traders. However, many traders, firms, or systems close out positions on Friday, to control risks, so they may be jumping back in on Monday... Now, the humans in the pits on Wallstreet or CME are no different.

When you add the algorithms into the equation, they simply multiply the effect because that's what they do - they increase volatility, liquidity, etc. So any human behavior pattern, that has small effect on the market is now multiplied. Also, algorithms are developed by humans, so in many instances, they reflect the desires of a human... Ex: Human Trader Brad is a swing trader but he closes out all positions on Friday so he doesn't hold any risk over the weekend. Brad also developed a system that trades a different strategy, but deploys the same EOW exit logic for risk mitigation. So you have End of Day Exits (Known as the 2 Oclock FU), and End of Week Exits. Then you have algorithms that multiply and increase price direction strength/momentum/vola/etc. So you can get massive price movements at certain times, and on certain days.

I could go on for years, detailing every reason why certain times of every day, or certain times of certain days or weeks, or certain minutes of certain hours have these patterns. Such as Economic & News reports, Earnings releases, Session open/closes, lunch time siesta, "effects of Next bar executions", start of week, end of week, start of day, end of day, start of bar, end of bar, etc...
​Basically, you can create a simple strategy that does not require Intense Quantitative analysis... just some simple run-of-the-mill technical analysis will work fine.

Here are Daily EC's from a Long Only strategy that has Generic Four lines of code, and allows three entries (1 contract per entry).

​If DayOfWeek( Date ) = DayOfWk and close open then Buy next bar at close limit;
​If DayOfWeek( Date ) = DayOfWk and close > open then sell next bar at close limit;
​If mp = 1 and close > open and openpositionprofit > 0 then sell next bar at close limit;
​if mp = 1 and close > open and closeW > closeW[1]  then sell next bar at close limit;

*Disclaimer: Historical performance whether live or simulated may not be indicative of future results. Trading Stocks, Options, FX, or Futures involves significant risks not suitable for all investors. Investors should only choose to invest funds ​they can afford to lose without impacting lifestyle. Price activity is not always predictable or repetitive, thus any strategy developed using historical data will be equally unpredictable. We do not guarantee our strategies or analysis methods will perform profitably and/or replicate results shown above, for any length of time. Before leasing/using our products, please consult your investment professionals to discuss if our products are right for your risk tolerances and objectives. Price activity is not always repetitive or predictable, thus any strategy developed using historical data will be equally unpredictable.

Monday

Tuesday

Wednesday

Thursday

Friday

So as you can see, if you are using a "Value" long only investing strategy, you could improve performance, simply by being a little more selective on which day(s) you allow entries to execute @Value.

Now, I realize these Equity Curves are not super great, but to offer decent performance from such a simple statement, imagine if you dug a little deeper and  traveled a little further into the abyss. Or even if you just wanted to add a few statements to help control risk... no problem. The point is, you can use simple methods in a creative way, you can implement foundations of complex reasoning into a simple structure. You don't always need 1,000 moving parts. 

You can implement behavioral finance into your concept with something as simple as analyzing Time - Based patterns. Remember, most systems are End of Bar systems... ( ie. they execute using "NEXT BAR AT MARKET" or "NEXT BAR AT CLOSE LIMIT" or "NEXT BAR AT BID or ASK... ETC."). Also, the majority of larger firms uses Daily bars and only trades U.S. sessions, so orders are executed in market open. Or, if they use a smaller bars size, like a 15-min... if you had to choose "The most Important part of the 15-min bar?", what would it be? The first 30-60 seconds, because the majority of systematic traders are using End of bar so their volumes are higher at the beginning, and Discretionary traders volume is higher afterwards. What's really interesting is when you break down, which is historically more profitable by analyzing and comparing future price direction to the volume ratio of each segment and trade type (Discretionary and Systematic), within the bar but that discussion is for another post.

For now, let's keep this in the framework of "investing". If you know the market has an upward bias and uptrend is still strong, and the 2 Oclock FU combines forces with the Friday End of Week Exit or the Monday End of Day Exit (because many Econ reports are released on Tuesday + Sluggishness of Blue Monday) to generate a massive downward price movement, you could place your Long Entry, just before market closes at an extreme/new price low... ie. value. The graphs above are applied to ES E-minisP500 Futures. However this concept can also be applied to Stocks, ETF's, Bonds, etc. Some markets will vary, and some may have specific patterns that no other market has, but the concept in general should be applicable.

This is just a single, simple, and common example of when you break down Time, Price, Days, Weeks, Volatility, Momentum, and Volumes within the context of Human & Systematic Behavior, there are REAL supporting reasons why these patterns exist, and why they are likely to exist in the future, which also makes it easier to identify why and when they will not work in the future.

If you really want to dive deep, you have to break it down into minute by minute, day by day, etc. analysis... the data is extremely useful but also very time consuming. 

I recently had someone email me about the performance of a strategy I created back in late 2005/early 2006 and traded for a few years. I remember the strategy being a daily mean reversion set up with an intraday pullback entry. I figured it probably had not done well over the last decade. I stopped trading in the middle of 2008 because I did not like how it was behaving. In the backtest it did well in bear markets but was not doing so in the middle of 2008.

I ran the strategy from 2007, using the rules as they were published and was pleasantly surprised by the results. A CAR of 25%. Overall not too bad. Wish I had still been trading it. This is an ​11-year out of sample test.

Then I remembered, didn’t this have insane results from 2000 to 2005? Here are those results.

Did you notice that 595% return in 2003? Now I am thinking what the heck happened since 2007. Look at the drop in yearly returns. Was the original strategy overfit and flawed? Did the markets change? If so, what is the difference? What follows is my investigation into trying to determine if the strategy is broken or the markets have changed.

I cannot share the rules because of the NDA I signed when it was created. What I can say is that it is a very typical mean reversion strategy that trades stocks.

I will include 2006 in the In-sample period because the return for the year was in line with previous years.

Curve Fit?

Was the initial strategy curve fit? I do not have the original code so I made a best guess of the parameters I would have optimized on and their values. The strategy CAR was 1.3 standard deviations from the average of all the variations. Even the worst variation still had a very good CAR from 2000 to 2005 and saw similar drop in performance. This variation may have been a little overfit but that is not the entire story.

Number of Trades

Is there a decline in the number of trades? Average number of trades per year:

• 2000 to 2006: 171
• 2007 to 2016: 88

Wow, a drop of 50%! That starts to explain a lot. But why less trades?

Trading Universe

Are fewer stocks passing our liquidity filter? This is the average per year:

• 2000 to 2006: 978,239
• 2007 to 2016: 861,763

A small decline but it does not explain the large drop.

Number of Setups

Since the strategy depends on intraday sell off, maybe we are seeing less setups. This is the average per year:

• 2000 to 2006: 5307
• 2007 to 2016: 2537

That explains the lower number of trades per year. We have less setups. This means we are seeing fewer stocks sell off and setting up for a mean reversion trade. This explains a lot. But let us see if it is the entire story.

Avg % P/L per Trade

Is the quality of the trade dropping too? Meaning what is the average % profit/loss per trade?

• 2000 to 2006: 6.25%
• 2007 to 2016: 2.73%

Another drop of 50%. A double whammy. These last two stats explain the drop in the performance. But I wanted to know more.

Volatility

Are the trades less volatile and is that why they are not as big? These are the average 100-day historical volatility of the trades:

• 2000 to 2006: 116%
• 2007 to 2016: 106%

That is not leading to the decrease. What is causing the decrease in average % p/l? I don’t know what else to look at.

Final Thoughts

Is this strategy broken? I don’t think so. But what has changed is the market, which has greatly reduced the returns. Having fewer setups and smaller gains on the trades seems to have caused the reduction in returns. As to why, my theory is that it’s because of the popularity of mean reversion strategies and quantified trading. Do you have any ideas on what is going on or other tests you want to see? Post them in the comments below.

Remember we had eleven years of out-of-sample data to work with to determine if the strategy was originally overfit or if it had broken, or if the markets had changed. Even with all these data it was not completely easy to figure out what was going on. The next time your strategy starts to perform poorly after 3 to 12 months, remember how hard it can be. I dropped the strategy after 6 months. It was not broken, the markets had changed.

--by Cesar Alvarez from Blog Alvarezquanttrading

Good quant trading,

With Christmas just a few days  away , I thought it would be interesting to see how the S&P behaves in the days just before Christmas. Do the days just before this holiday tend to be bullish, bearish, or neutral?

 To test the market behavior just before the Christmas holiday I will use the S&P Cash index back in 1960. I will create an EasyLanguage strategy that will enter a trade X days before Christmas and close that trade on the opening of the first trading day after Christmas.  Each trade will dedicate $100,000 to purchase shares. Stops, and both commissions and slippage are not utilized in this study.

Ten Days Before Christmas

First let's look at the ten days before Christmas. What happens if we enter a trade X days before Christmas and close that trade on the open after Christmas? By using TradeStation's optimize feature I can systematically test each day over the historical data. The results of each test is the generated P&L for each iteration and is depicted in the bar graph below. Looking at the graph, each bar on the x-axis represents the number of days before Christmas.

It appears that the 10 days before Christmas all show positive P&L. In general, the longer you're holding period before Christmas the better.

Ten Days After Christmas

Using a similar trading system, I will look at entering a trade on open of trading day following Christmas and holding that trade for X days. Below is a bar graph showing the days 1-10 after Christmas. Again, each bar represents P&L and the x-axis is the number of days the trade is held.

Historically, all days after Christmas in our study have returned positive results. Unlike the 10-days before Christmas, in this case it appears there is not much gain for holding beyond five days.

The Christmas Trade

Based on the information above, which seems to show a strong bullish biased for the days immediately before and after Christmas, I'm going to create another strategy that will open a trade five days before Christmas and closes that trade five days after Christmas. I picked five days simply because it was the middle value (1-10) for the days before and after Christmas we tested.  Last year's Christmas Trade (December 2016) was a scratch trade. It's pictured below.

When you combine all the trades going back to 1960 we get the following equity curve and performance. 

Conclusion

There certainly does seem to be a very strong bullish tendency around Christmas. Can you take advantage of this in your trading? Perhaps. Remember, the code provided below this article is not a complete trading system, but an indicator to help me gauge the market behavior around the Christmas holiday. If you have trading systems or trade a discretionary method around these days before and after Christmas, you might use this knowledge to ignore short signals, or modify your exit.

Download

Below is the free EasyLanguage code used to generate the Christmas Trade as both a TradeStation ELD file and text file. You will also find a copy of the TradeStation WorkSpace and the performance report as an Excel document.

Christmas Trade (TradeStation ELD)
Christmas Trade WorkSpace (TradeStation TWS)
Christmas Trade Strategy Code (Text File)