ETMA_The Evolution

Why Wall Street traders are obsessed with Jesse Livermore.
Lucinda Shen​
Jul. 17, 2015, 11:03 AM

Slow And Steady Earns The Simoleons.
Trading The Turtle System On Currencies.

..on currencies.. very nice story...still, not what im exactly doing on. Ill give you some results for last 6 months for you to comment on Currency intraday trendfollowing - very similar piece as this article.

Any sharing is appreciated 21, just make sure its live results and not Demo please, thanks.

end of game eh...wales couldnt settle and deserved victory by englaand this time

yeah, long story short - where would we be without the demo ya..rinse and repeat

The pressure finally paid off even though by chance for Sturridge, not to mention vardy's 1st 1000 % off side goal .
After watching the 1st goal again it seems that ashley williams gave vardy the pass by the head which turned him from an offsider to an insider .

Hedge Fund Style Research :

Taking The Financial Road Less Traveled The Felder Report

Trend Following Wizards – May
June 16th, 2016

The month of May was negative overall for the Wizards and turned the performance for the year in the red too.

The Breakout Bulletin
The following article was originally published in the September 2007 issue of The Breakout Bulletin.

Automated System Development
In the July 2006 issue of Futures magazine (ref. 1), I read an interesting article by Mike Barna. He described a computer program he developed that automatically generates trading systems using a genetic programming algorithm. Very few details about how the algorithm works were provided, and the article was laced with technical jargon. However, the basic idea was clear. He was using a computer algorithm to construct trading rules and combine them in different ways in order to find the set of trading rules that worked best. It was optimization of the trading system development process, rather than optimization of trading systems per se. He followed that article with one the next month that provided an example of a trading system produced by this process (ref. 2).

When I accessed Mr. Barnas web site, I was interested to find that he was getting ready to sell a commercial version of his software. My interest quickly faded when I learned he was planning to sell the program for $60,000 per copy. My first thought was I wonder if I could do something like that myself. So, this month, Im presenting my own simplified version of automated system generation.

On his web site, it says that his product is the result of years of hard work. My version took about three days, so you can probably guess its not as complicated or sophisticated as Mr. Barnas program. On the other hand, Im not only disclosing how I did it, Im giving you the code for free. As I suspect youll agree, its surprising how much one can actually accomplish with some fairly simple algorithms.

Price Pattern Rules

In principle, any type of indicator or trading logic could be included in the trading system generator Ive developed. However, to keep things fairly simple for the purposes of this newsletter, I decided to restrict the rules of the generated trading systems to price patterns. Each entry rule of a generated trading system will have the following form:
P1[N1] Ineq P2[N2]
where P1 and P2 are prices (open, high, low, or close), N1 and N2 are the number of bars to look back (e.g., Close[2] is the close two bars ago), and Ineq is an inequality, either <= or >=. Examples of rules include the following:
Close <= Close[2]
Low[2] <= High[10]
High[3] >= Close[4]
and so on. P1, P2, N1, N2, and Ineq are all variables to be determined by the system generation process.

N1 and N2 will be restricted to the range 0 20. Also, the number of rules, NRules, will be a variable with values ranging from one to 10. A trade entry will be triggered if all the rules are true. In that case, the entry will be taken at the open of the next bar. The trade direction will be set beforehand, so that the system will be generating systems that are either all long or all short trades. This is done because some possible sets of rules will have no obvious logical inverse, so it wouldnt be possible to simply reverse the logic for long trades to get a short entry condition, or vice-versa. To obtain trading logic for both long and short trades, the system can be run twice, once for long trades and the second time for short trades.
Trades will be exited at the market after a fixed number of bars, NX, which will range from one and 20.

Finding the Rules

The key to this process is finding candidate trading systems. A system can consist of between one and 10 rules of the form shown above. We enter at market if all the rules are true, and we exit a certain number of bars later. If this were coded as a traditional TradeStation system, wed have no practical way to optimize it because TradeStation uses a direct optimization method in which all possible combinations are considered. In this case, with a maximum of 10 rules, there are more than a trillion combinations, not even considering the parameter values.
A different method, such as the genetic algorithm that Mr. Barna used, is needed. However, rather than program a genetic algorithm for this article, I decided to use a poor mans genetic algorithm. At each step of the optimization, the values for each variable (P1, P2, N1, N2, Ineq, NRules, and NX) will be chosen randomly. There will be multiple values of P1, P2, N1, N2, and Ineq depending on the number of rules, NRules.
Each step of the optimization generates a different trading system as the variables are randomly selected. If the performance results of the system meet the requirements entered by the user, the generated system will be written to a file in EasyLanguage code.

Putting it All Together
The code for the AutoSystemGen system is shown below.
{
AutoSystemGen
This system is designed to automatically generate profitable
trading systems based on price patterns. When the system is
optimized, it randomly generates price patterns and writes
Easylanguage trading system code for each system that meets
specified performance criteria. After the optimization is
complete, the code for each successful system can be found
in the text file specified in the function WriteSystems.

Mike Bryant
Breakout Futures
www.BreakoutFutures.com
[email protected]

Copyright 2007 Breakout Futures

}
Inputs: OptStep (0), { Optimization step; optimize this var }
TradeDir (1), { +1 -> long trades; -1 -> short trades }
reqNetProf(0), { minimum required net profit }
reqMaxDD (0), { required max drawdown limit }
reqNTrades(0), { required minimum number of trades }
reqPerWins(0), { required minimum percentage of wins }
reqProfFac(0); { required minimum profit factor }

Var: NRules (0), { Number of rules/patterns to use }
NBarExit (0), { Number of bars to hold trades }
ii (0), { Loop counter }
ProfFac (0), { profit factor }
FuncRet (false),{ function return variable }
EntNext (false);{ logical flag for entering next bar }

Array: PriceL[10](0), { 0 - 3 for O, H, L, C for left-hand side }
PriceR[10](0), { 0 - 3 for O, H, L, C for right-hand side }
InEq[10] (0), { 0 - 1 for >=, <= }
DaysL[10] (0), { days back for left-hand price }
DaysR[10] (0); { days back for right-hand price }

{ Randomly select values for the variables that define the rules }
If BarNumber = 1 then
FuncRet = GetPatVars(PriceL, PriceR, InEq, DaysL, DaysR, NRules, NBarExit);

{ Evaluate the price patterns/rules to determine if a trade should be placed }
EntNext = true;
For ii = 0 to NRules - 1 Begin
EntNext = EntNext and EvalPattern(ii, PriceL, PriceR, InEq, DaysL, DaysR);
End;

{ Place the trade, either long or short }
If EntNext then Begin
If TradeDir > 0 then
Buy next bar at market
else if TradeDir < 0 then
Sell short next bar at market;
End;

{ Exit the open trade NBarExit bars after entry }
If BarsSinceEntry = NBarExit then Begin
If MarketPosition > 0 then
Sell next bar at market
else if MarketPosition < 0 then
Buy to cover next bar at market;
End;

{ Write out the trading system code if the system is successful }
If AbsValue(GrossLoss) > 0 then
ProfFac = GrossProfit/AbsValue(GrossLoss)
else
ProfFac = 100;

If LastBarOnChart and NetProfit >= reqNetProf and
AbsValue(MaxIDDrawDown) <= AbsValue(reqMaxDD) and
TotalTrades >= reqNTrades and
PercentProfit >= reqPerWins and
ProfFac >= reqProfFac then
FuncRet = WriteSystem(OptStep, TradeDir, PriceL, PriceR, InEq, DaysL, DaysR,
NRules, NBarExit, "C:\AutoSysGen-Output1.txt");

If you look at the system inputs, the first input is called OptStep. To run this system, you optimize it in TradeStation by varying this input from 1 to some large number, such as 10,000, in steps of 1. This will cause the system to generate, for example, 10,000 different trading systems. The ones that meet the specified performance criteria are written to the file shown as an input to the WriteSystem function (C:\AutoSysGen-Output1.txt). The performance criteria are specified via the system inputs (reqNetProfit, reqMaxDD, etc.).

Most of the hard work is performed by the functions that the system calls. The function GetPatVars randomly selects the values for the variables that determine the trading rules. To determine whether or not a trade entry will occur on the next bar, the price pattern rules are evaluated by the function EvalPattern. Finally, if the system meets the performance criteria, the corresponding EasyLanguage code is generated and written out to a text file by the function WriteSystem. The code for the AutoSystemGen system and all the functions is available on my download page.

Example
As an example, consider the 30-year treasury bond futures market (symbol @US.P in TradeStation 8.2). I optimized the AutoSystemGen system over the past 20 years of t-bond prices with the OptStep input optimized from 1 to 10000. This means the system evaluated 10,000 different trading systems. I ran the optimization twice, once for long trades and once for short trades. For performance criteria, I chose the following requirements: net profit of at least $30,000, worst-case drawdown no more than $7500, at least 200 trades, percent profitable of at least 50%, and profit factor of at least 1.2. On my dual core process computer running Vista, it took approximately 10 minutes to run each optimization (10,000 systems per optimization).

The systems generated by this process are shown below. These are the systems written to the file AutoSysGen-Output1.txt by the WriteSystem function. The first ones are the long-only systems, followed by a short-only system (the only one that met the performance criteria).

System 2332, @US.P, 9/17/2007 12:23:00, Long Trades
Net Profit = 53562.50, Max DD = -7381.25, Num Trades = 250, Percent Wins = 56.80, Prof factor = 1.631
{ System code starts here... }
Var: EntNext (false);
EntNext = Open[2] >= Low[16] and
Low[9] >= Low[3] and
Close[14] <= Low[6] and
High[1] >= Low[3];
If EntNext then
Buy next bar at market;
If BarsSinceEntry = 2 then
Sell next bar at market;
{ End system code }

System 5771, @US.P, 9/17/2007 12:27:00, Long Trades
Net Profit = 42145.00, Max DD = -5733.75, Num Trades = 207, Percent Wins = 57.00, Prof factor = 1.631
{ System code starts here... }
Var: EntNext (false);
EntNext = High[7] >= Low[19] and
Close[20] >= Close[5] and
High[18] >= Low[2] and
High[2] <= Open[6];
If EntNext then
Buy next bar at market;
If BarsSinceEntry = 2 then
Sell next bar at market;
{ End system code }

System 7622, @US.P, 9/17/2007 12:29:00, Long Trades
Net Profit = 59348.75, Max DD = -7222.50, Num Trades = 208, Percent Wins = 60.58, Prof factor = 1.924
{ System code starts here... }
Var: EntNext (false);
EntNext = Low[2] <= High[9] and
Open[11] >= Open[18] and
Close[17] <= Low[18];
If EntNext then
Buy next bar at market;
If BarsSinceEntry = 3 then
Sell next bar at market;
{ End system code }

System 7718, @US.P, 9/17/2007 12:29:00, Long Trades
Net Profit = 35526.25, Max DD = -6936.25, Num Trades = 292, Percent Wins = 56.85, Prof factor = 1.418
{ System code starts here... }
Var: EntNext (false);
EntNext = Close[3] >= High[19] and
High[8] >= Low[9] and
High[6] <= Open[10] and
Low[16] <= High[3];
If EntNext then
Buy next bar at market;
If BarsSinceEntry = 1 then
Sell next bar at market;
{ End system code }

System 6160, @US.P, 9/17/2007 12:42:00, Short Trades
Net Profit = 31277.50, Max DD = -6846.25, Num Trades = 369, Percent Wins = 51.76, Prof factor = 1.297
{ System code starts here... }
Var: EntNext (false);
EntNext = High[9] >= Low[6] and
Close[15] >= High[8] and
High[7] <= Low[20] and
High[6] >= High[7];
If EntNext then
Sell short next bar at market;
If BarsSinceEntry = 1 then
Buy to cover next bar at market;
{ End system code }

The listing for each system includes the system number (corresponding to the OptStep input), market symbol, current date, and whether the system is long-only or short-only. The next line contains a few summary performance statistics to help in evaluating each system. Finally, the system code is shown. To evaluate the systems in TradeStation, the code between the two comment lines ({ }) can be copied and pasted into a strategy in TradeStation, then run in the chart window.

For example, I copied the first system shown above (#2332) to TradeStation and saved it as a strategy. When I ran this on the @US.P chart, I obtained the following equity curve:
http://www.adaptrade.com/BreakoutFut...l6No1/Fig1.gif
Figure 1. Long-only system for t-bonds, last 20 years, with $15 per trade deducted for trading costs, generated by system AutoSystemGen.
The last system in the output file is a for a short-only system (#6160). When saved in TradeStation as a strategy and applied to the same t-bond chart, the following equity curve is produced:
http://www.adaptrade.com/BreakoutFut...l6No1/Fig2.gif
Figure 2. Short-only system for t-bonds, last 20 years, with $15 per trade deducted for trading costs, generated by system AutoSystemGen.
With a small amount of additional effort, the two systems could be combined into a single system that generates the long and short trades in the same system.

Comments
Automatically generating trading systems is an attractive idea. The traditional process of developing a trading system is extremely time consuming and involves systematically eliminating many ideas that simply dont work. Also, we all have biases about how the markets work, and these biases affect how we develop trading systems. Hopefully, our biases guide us in the right direction, but they can also limit the possible systems we might come up with. Rather than starting with a market bias and a limited set of rules, an automatic system generator starts with a wide array of possible rules and finds what works without bias while quickly eliminating what doesnt.

The downsides of automatic system generation are (1) its not a trivial matter to develop a good system generator, and (2) its an optimization process, with all the caveats of any trading system optimization. The AutoSystemGen system described here is a very simple system generator limited to price patterns with a simple exit rule. However, the process could be expanded to include other types of indicators and system rules. To make it suitable for day trading, an exit-on-close rule could be added to each generated system. To find better systems faster, the random process of assigning values to variables could be replaced with a genetic algorithm.

Its notable that the random selection of values for variables is as effective as it is. A genetic algorithm starts with a randomly drawn selection of values, but then modifies the values to evolve other sets of values. Randomness is introduced periodically in genetic algorithms to shake things up and make sure enough variation is introduced into the search process. For the AutoSystemGen system, Ive effectively taken a genetic algorithm and eliminated everything but the randomness. And the algorithm is still fairly effective.

The AutoSystemGen system is optimizing both the selection of rules and the parameter values of the system simultaneously. As with any type of system optimization, its important to test out-of-sample, preferably in real time. Real-time tracking of the generated systems prior to committing real money is the best way to be sure the systems are not over-fit to the market. A system that works well in real time following optimization has the best chance of holding up well in actual trading.

References
1. Mike Barna, Building Trading Systems the Automatic Way, Futures, July 2006, pp. 44-46.
2. Mike Barna, Going for the Gold -- Automatically, Futures, August 2006, pp. 44-47.

That's all for now. Good luck with your trading.

Mike Bryant
Breakout Futures

Bass I am having no luck with the link. Can you please check it mate. :-)

Try it now.

You are the bestestestest Bass

FX Volatility Chart Book.

TradeStation-Labs-AC-FX-Volatility-Chart-Book

Machine Learning for Trading .

Course Summary

This Free course introduces students to the real world challenges of implementing machine learning based trading strategies including the algorithmic steps from information gathering to market orders. The focus is on how to apply probabilistic machine learning approaches to trading decisions. We consider statistical approaches like linear regression, KNN and regression trees and how to apply them to actual stock trading situations.

Georgia Tech.

TradeStation Strategy Testing - Violating These Steps Will Damage Your Account

One of the most rewarding experiences for a TradeStation trader is to pick up a performance report that proves their great strategy idea is indeed a profitable strategy. Strategy testing done properly, as is outlined in this article, can verify the efficacy of your trading strategy and give you confidence to start trading it. But be forewarned, strategy testing done improperly can lead you toward financial destruction.

Strategy testing done incorrectly can result in false hope in a losing strategy. Here is a dramatic example.

Strategy Performance Report BEFORE Proper Back Testing

http://www.customizedtrading.com/tmp/Grail_Before.JPG

Same Strategy - Performance Report AFTER Proper Back Testing Followed

http://www.customizedtrading.com/tmp/Grail_After.JPG

A trader recently shared his experience of getting great results from strategy testing his idea, but after trading it live in the market, he was losing money every day. He was baffled about what he did wrong. Having gotten excellent results on his back-testing performance report, he wondered why his promising strategy was draining his trading account. The problem was he violated several of the proper steps necessary for reliable strategy testing.

With the knowledge of how to get an accurate performance report you will be able to trust your strategy in live trading and protect your trading account. In order to properly test a strategy, there are 5 main steps that are vital to follow; configure TradeStation, "in-sample data" testing, "out-of-sample data" testing, live forward testing on the simulator account, and real live trading execution.

Step 1: Configure TradeStation

Before you begin testing your data, you must configure TradeStation so that the data it pulls onto your performance report will be accurate. Follow these 3 critical items to properly configure TradeStation.

(a) In your TradeStation platform menu, go to format symbol and give TradeStation a starting and ending date to test. This historical date range is called the "in-sample data." Do not include the most recent six months in this in-sample data. The most recent six months is called the "out-of-sample data," and it will be used later during your "out-of-sample data" testing step.

(b) Next, in your TradeStation platform menu, go to "format strategy" and select "properties for all." Now select the "general" tab and enter the commissions and slippage (be as realistic as possible, or estimate too high if you are not sure). If this step is skipped, then the strategy testing performance report will be meaningless. If this is not done you might have a good looking performance report equity curve, but as soon as you enter the commissions and slippage figures the equity curve can reverse into an underwater equity curve.

(c) The last configuration step is under "properties for all" under the "general" tab. Look in the bottom left section called "strategy testing resolution." Check the "look-inside-bar back-testing" option and then select the smallest time frame available for your chart style to make the strategy testing more closely resemble live data. When strategy testing, TradeStation uses the open, high, low, and closing data, thus the larger the time frame bar, the more distorted the strategy testing performance report can be. This "look-inside bar back-testing" option will make the computer do a lot more strategy testing calculations. This may really slow down your performance report generation, so please be patient. For an accurate performance report you must use the "look-inside bar back-testing" option.

These configuration steps are critical to getting an accurate performance report, so be sure this is completed precisely before continuing. Once TradeStation has been configured correctly, you can begin testing your strategy.

Step 2: In-Sample Data Testing (also called Back testing)

You are now ready to start testing your strategy idea. We will begin with testing the in-sample data that you set up for testing during the configuration steps. Begin with bringing up a TradeStation performance report. Right now I have a performance report in front of me that I will refer to, but you will be looking at your own performance report to analyze your own numbers. This is what we will be referring to in the steps below. There are 7 sub-steps to in-sample data testing, as follows:

First, look at how many trades the strategy made. To reduce strategy testing errors, where error is defined by [ error = 1 / Square Root (Number Trades In Test) ], you want at least 400 trades to reduce the margin for error to 5% in your strategy testing results. At 100 trades you have a 10% margin for error.

Critical Note: The greater the number of inputs in your strategy that you optimize, the greater the number of trades required to keep from over optimizing your strategy.

Also look at how many times the strategy traded on average per day. The more often a strategy trades the more profit it can generate.

In the performance report that I am looking at, it traded 397 trades in the last 3 1/2 months, averaging 5.3 trades per day.

Second, look at the Average Trade Amount. It needs to be large enough that slow order fills and/or larger than normal slippage does not kill the profitability of the strategy.

In my report the Average Trade Amount is $162.32. The commissions and slippage amount as defined in the set up steps is already subtracted in this performance report.

65% of the time this strategy trades 1 contract.
35% of the time this strategy trades 3 contracts.
10% of the time this strategy trades 5 contracts.

Third, look to see if the Profit Factor and Ratio Average Win-Average Loss are both above 1.5 and the percentage of winning trades around 45% or better
This strategy had a Profit Factor of 1.83.

This strategy had a Ratio Average Win-Average Loss of 2.28 (2.28 means breakeven is around 28% Percent Winning Trades)
On this strategy the Percent Winning Trades was 44.58%.

Fourth, look at the trade list page and assess the profit run ups and draw downs column. Notice how many trades made money and how much money they made before the trade exit occurred. Looking at what amount of money was made in relation to the profit run up and draw down, you want to know if managing the trades could generate more profits. The example used here shows that a good percentage of trades made much higher profits than where the automated exit points occurred.

Fifth, look at the three draw down (DD) numbers. I like to see the largest number at 15% or less of the Total Net Profit and the Max DD at 5% or less of the Total Net Profit (these numbers tell about the draw down risk level during your trades).

Total Profit - $64,440
Peak to Valley DD - $8,960 is 13% of Total Profit
Close to Close DD - $7,120 is 11% of Total Profit
Max DD - $3,420 - 5% of Total Profit

Sixth, Looking at the Largest Losing Trade on the report, I like to see 5% or less of the Total Net Profit. In my report the Largest Losing Trade that occurred was $2,580 which is 4% of Total Net Profit.

Seventh, I review the length of time in the average trade. Does the average time in a trade comply with the golden rule of trading; "cut your losses quickly and let your profits run?" You will also want to see if the strategy is built using only profit exits (no real stop loss exits). It might have a nice looking report, but it could show a messed up ratio between average bars per winning trade verses average bars per losing trade if there are no stop loss exits. Here are my average bars:

Average bars per winning trade 7.24
Average bars per losing trade 3.51 bars

This strategy complies with the golden rule of trading. Notice how it cuts losses quickly, at an average of 3.51 bars, and lets the profits run for an average of 7.24 bars.
So what does this all mean? It means this strategy has passed the historical strategy testing phase of strategy testing.

Step 3: Out-of-Sample Data (also called "Walk Forward Testing")

Once you have tested your in-sample data and have determined that your strategy is worthy of continued testing, you can now test your strategy against the out-of-sample data. If you have not yet tested your in-sample data, do that before proceeding.

To test the out-of-sample data we use the most recent 6 months of data available that you reserved in step 1(a). In step 1(b) of this article, we talked about configuring TradeStation and covered entering commissions and slippage and using the look-inside-bar back-testing option, which must be used to run any performance report used in your strategy testing. Be sure you have configured TradeStation correctly before moving on.

Go into format symbol and change the date range to include ONLY the "out-of-sample data" date range that was NOT used during the strategy testing on "in-sample data." This is referred to as testing on the "out-of-sample" data.

Begin with bringing up a TradeStation performance report on the "out-of-sample" data and review all the items that we discussed in step 2 above on this "out-of-sample" performance report. The closer it performs to the Step 2 in-sample data performance report, the more robust the strategy is. This suggests that the results were not from curve fitting and you have a good chance of having a viable strategy. This out-of-sample date range test is much more important than the strategy testing step on the in-sample-data for finding a successful strategy. It is a good idea to test multiple different "out-of-sample" date ranges, which is called Walk Forward Analysis.

Robustness: Perry J. Kaufman stated, "Practically speaking, a robust trading strategy is one that produces consistently good results across a broad set of parameter (input) values applied to many different markets tested for many years."

If the strategy fails during this "out-of-sample data" test, do NOT optimize using your reserved out-of-sample data. This would defeat this vitally important step in strategy development. You can go back to your strategy and fix it, or else drop it and develop a new strategy idea.

One caveat - if your strategy is capitalizing on a certain market condition, like the current volatility, and then you out-of-sample data test a non-volatile date range, it may not perform well, However in our next phase of testing, Live Forward Testing, it could prove to be successful since we are still in a volatile market. You must understand why your strategy works, under what market conditions it performs well, and in what market conditions it does not perform well.

Now that you have tested your out-of-sample data and your strategy is promising, you are ready to live forward test your strategy on the simulator account.
At this point you have configured TradeStation so your performance report will be accurate, you have tested your in-sample data and your out-of-sample data and your strategy still looks great. Now you are ready to live forward test your strategy on the simulator account.

Since step 3 "Walk Forward Testing" is so vital to properly test a trading strategy, I highly recommend reading Chapter 11 of Robert Pardo second edition book titled "The Evaluation and Optimization of Trading Strategies".

Step 4: Live Forward Testing on the Simulator Account

During your live forward testing on the simulator, you want to verify that the live data feed entries and exits are similar to historical entries and exits. After you have made live data trades for a day, save the live trade list. Now reload this same chart so the strategy recalculates based on the historical for this same day. Record the historical trade list and compare the live entries and exits to the historical entries and exits. Are they the same or at least similar? Do you understand the differences and the impact your "Live Data" test says about your strategy?

Only by monitoring the program daily can performance be seen under real "live" market conditions. Continue Live Forward Testing on the simulator until you are totally comfortable that your strategy works on live data. Real time results will often be less profitable than your historic results. The key question is does the real time testing show that you have a profitable strategy that is worth trading?

Step 5: Real Live Trading Execution

Once you have done your due diligence and are comfortable with your strategy results on the simulator, you are ready to trade live. Since you are trading a brand new strategy with real money, start with a significantly reduced position sizing risk of 1/4 of 1% of your account equity at risk per your stop loss point per trade. Continue trading with minimal risk until you have verified everything is working properly within your new strategy during live order executions.

Once your strategy is making money in the live market, slowly over time begin to increase your position sizing risk. Move your risk upward from 1/4 of 1% toward 1%. Continue trading at 1% risk until you have several weeks to months of consistent trading performance. If you want to be aggressive and use more, you can continue to increase SLOWLY toward 2% but I would NEVER recommend going over the maximum of 3% of your account equity at risk per trade.

If you follow the 5 steps as outlined in this article, you will now be able to confidently strategy test any strategy idea that you have. Keep this article for reference so the next time you are inspired with a great idea, you will be able to prove it out, protect your TradeStation trading account, and have confidence in live trading your strategy.
Click on this link to learn how to quickly and accurately strategy test any trading idea you might have.

Trend Following UP in June (Thanks Brexit)
July 5, 2016 by Jez Liberty

June 2016 Trend Following: UP +2.22% / YTD: +0.47%

Brexit might have been globally thought of as bad news for the markets, but it was good for trend following. It marked a quick up movement in last month’s performance, quickly reversing the negative performance of the month to turn it back positive, after the 23rd June vote. The YTD performance is slightly back in positive territory.

MACHINE DESIGNED TRADING SYSTEMS ARE HERE!
www.tradingsystemlab.com

TSL Version 1.1 Review

http://slideshowes.com/doc/281477/ma...utures-traders

Another Trading Systems Lab

A Visual Introduction to Machine Learning.

053 – Should system traders override their systems?

Download the transcript for Episode 53 .

The Breakout Bulletin
The following article was originally published in the December 2007 issue of The Breakout Bulletin.

Exits for All Occasions

When most people think about trading systems, they probably think about how the system enters the market. In fact, trading systems are usually described in terms of their entry technique, such as breakout systems, moving average crossover systems, Fibonacci retracement systems, and myriad other methods for entering the market. Even the terms "counter-trend" and "trend-following" refer more to the entry than the exit.

Despite the common focus on entry techniques in trading, you may have come across the assertion that exits are more important than entries. In my experience, that's usually true. Why? One possible reason is that most market action is random. A good trading system finds at least some signal in all that noise. But with all the noise in the market, a substantial percentage of entry signals may be wrong.

A long-term trend following system, for example, may be right only 40% of the time. Despite the low percentage of winning trades, it can still be highly profitable if it keeps the losing trades smaller than the winners. The way it does that is by cutting the losses short and letting the winners run. In other words, it's profitable because of how it handles the exits.

Generally speaking, I think it's fair to say that exits are the principal method of controlling the intrinsic risk/reward characteristics of a trading system. Whether the system looks for a quick profit or holds the trade through the market's ups and downs depends on the exits. Likewise, whether a losing trade is cut off quickly or given more room to move is determined by the exits. Exits are truly the way to implement "cut your losses short and let the winners run."

Note that I use the word "intrinsic" when describing the risk/reward characteristics of a trading system to differentiate the rules and logic of a trading system from position sizing. Certainly, position sizing can be used to improve the overall risk/reward ratio of a trading system, but position sizing is an external factor, apart from the rules and logic of the system. The focus of this article is on the rules and logic of trading systems, rather than on position sizing.

Exit Types
The following list is not exhaustive but it includes some of the most common types of exits you may encounter or consider for your own trading systems:

Stop and Reverse. This is basically an "exit-less" exit. Stop and reverse systems reverse from long to short and back to long again. If you're long one contract, for example, you would sell two to close out the long trade and go short. You're never flat the market with this type of exit because each exit is also an entry in the opposite direction.

N Bars from Entry. Exit the trade at the market N bars from the bar of entry, where N can be any number greater than zero. For example, you might exit the trade 10 bars from the entry. The duration of the trade will depend on the bar size; e.g., 5 min bars or 60 min bars.
Time of Day. Rather than exiting relative to the entry, as with the previous method, you exit at a specific time of day, such as at 10:30 am. As a special case, this exit also includes exiting at the end of the trading session.

Money Management Stop. This is a commonly used exit type that uses stop orders to limit the risk of a trade. For a long trade, a sell stop order is placed below the entry price. For a short trade, a buy stop order is placed above the entry price. When the stop is hit, the loss is limited to the size of the stop plus slippage. Common methods on which to base the size of the stop are a fixed dollar amount, a fraction of the average true range, or as a percentage of price.

Trailing Stop. This type of exit uses stop orders to lock in a percentage of the open profit after a specified level of open profit -- the floor -- has been reached. For example, after an open profit of $500 has been reached on a long trade, you might place a stop order below the market so that 50% (or $250) of the open profit will be retained if the market reverses. The floor amount is typically computed based on either a fixed dollar amount or a fraction of the average true range. Note that a breakeven stop is a special case of the trailing stop where the percentage of profit to lock in is zero.

Profit Target. The profit target uses limit orders to exit when a specified price has been reached, representing a profit for the trade. For a long trade, the limit order is above the market; for a short trade, it's below the market. Like a trailing stop, a profit target can help avoid giving back open profits when the market reverses. However, profit targets also place a limit on the maximum profit that's possible from a trade.
Logical conditions/trading logic. In addition to the exit types listed above, just about any logical condition, such as those used for trade entries, can be used to exit a trade.

http://www.adaptrade.com/_themes/djm...s-9/bullet.gif

Price Patterns. For example, a series of consecutive lower closes might be used to exit a long trade.
http://www.adaptrade.com/_themes/djm...s-9/bullet.gif

Trend Indicators. For example, moving averages, momentum, and MACD could all be used to signal a trade exit.
http://www.adaptrade.com/_themes/djm...s-9/bullet.gif

Trend Strength. For example, when the ADX indicator, which measures trend strength, declines below a certain level, a trend-following trade might be exited.
http://www.adaptrade.com/_themes/djm...s-9/bullet.gif

Oscillators. Stochastic, %R, RSI, Bollinger bands, and other oscillators measure over-bought and over-sold conditions. A long trend trade might be exited when an oscillator crosses below the over-bought level, indicating the end of an up-trend. On the other hand, if the trade has been entered on weakness, such as a pull-back, a short-term trade might be exited when the oscillator crosses above the over-bought level.

http://www.adaptrade.com/_themes/djm...s-9/bullet.gifSupport/resistance. Support and resistance levels can be used either as money management stop prices or as target prices.

A Comparison Study
To test and compare different exit types, a simple system was written in TradeStation's EasyLanguage. The system, called ExitTests, is available on my downloads page. ExitTests enters trades using a 20-bar channel breakout: it buys at the highest high of the last 20 bars plus 1 point on a stop and sell short at the lowest low of the last 20 bars minus 1 point on a stop. Channel breakouts tend to work fairly well as trend following systems.
The following exits were tested:

1. Stop and reverse.
2. 20 bars from entry.
3. Money management (MM) stop: size equal to 1 x average true range (ATR) of the last 20 bars -- ATR(20).
4. Trailing stop: floor at 1 x ATR(20); 50% profit lock.
5. Target: 1 x ATR (20) from the entry.
6. Moving average: exit long when close is below moving average (MA) of last 20 closes -- MA(20); exit short when close is above MA(20).
7. RSI: exit long when RSI of the last 14 closes -- RSI(C, 14) -- crosses above 70; exit short when RSI(C, 14) crosses below 30.

In addition, the following combinations of exits were tested:

1. N bars with trail
2. N bars with target
3. N bars with MA
4. N bars with RSI
5. MM stop with trail
6. MM stop with target
7. MM stop with MA
8. MM stop with RSI

The same parameter values were used for all tests and all markets. These values, as listed above, were not optimized.
Each exit was tested over the following five futures markets: crude oil (CL), E-mini Russell 2000 (ER2), Japanese Yen (JY), T-bonds (US), and wheat (W). The test period was 20 years of daily data where available (six years for the ER2), and no commissions or slippage were deducted. The tests were conducted in TradeStation 8.2.
The results are shown in the following figures. The corresponding Excel spreadsheet is available online on my downloads page.

http://www.adaptrade.com/BreakoutFut...l6No2/Fig1.gif
Fig. 1. Exit test results for 20-bar channel breakout system, single exit types.


http://www.adaptrade.com/BreakoutFut...l6No2/Fig2.gif
Fig. 2. Exit test results for 20-bar channel breakout system, combination exit types.

The figures display the net profit (Net Prof), worst-case drawdown (DD), and profit factor (PF) for each market and exit type. The best exit type for each market is highlighted in green, and the worst exit type is in red. The best and worst were chosen subjectively based on a combination of the three performance metrics (profit, drawdown, profit factor).

It's apparent from the figures that there is no consistently best exit type. In fact, each market has a different best exit type. This suggests that it may make sense to customize the exit rules to the market. However, for some systems, such as long-term trend-following systems, the number of trades from one market may be too small for statistical significance. In that case, it may be necessary to use the same rules for all markets.
Overall, the combination of N bars from entry with a profit target ("NB-Targ") was the best exit, as judged by average net profit and average net drawdown. The advantage of exiting at N bars from entry is that the exit is unaffected by market volatility. It acts as a way to get out of a trade that isn't working. It makes sense that this works well with a profit target. This combination is basically saying "either we hit our profit goal within N bars or we get out."

The worst exit, somewhat surprisingly, was the combination of a money management stop and a profit target ("MM-Targ"). This combination was worse than either the money management stop or the profit target by itself. The reason for this is that the profit target was relatively small and the same size as the stop. This resulted in a large number of small trades, many of which were stopped out. Without the profit target, the trades were much longer in duration, and the profits were larger. This illustrates that when a money management stop and a profit target are combined, they have to be sized relative to each other. In this case, because the channel breakout method typically has less than 50% profitable trades, it would be better to increase the size of the target relative to the stop so that the average winning trade is larger than the average loss.

Among the single exit types, the best overall was the target exit, which was also the most consistent. The worst single exit type was probably the RSI. Considering that the channel breakout method is a trend-following method, it's probably not surprising that an oscillator performed poorly as an exit technique. The trailing stop probably returned the most variable results. The best results in the Yen and the worst results in crude oil were both achieved with the trailing stop. This may just mean that the size of the floor and/or the lock-in percentage for the trailing stop are market dependent.

One general conclusion from this study is that the type of exit chosen for a trading system can make a big difference in the system's performance, even the difference between winning and losing. How different exits are combined is also clearly important. Although different results would be obtained with different entry rules or different markets, hopefully this study will give you some good ideas for your own trading system development. Just remember to test every assumption and perform good out-of-sample testing and/or real-time tracking before committing real money.

That's all for now. Good luck with your trading.

Mike Bryant
Breakout Futures