Moving averages are the first fool’s errand we make as traders. If only it was smoother, but still responsive. Predictive, not just reactive. And so many hours are lost clicking through TradingView PineScripts or MetaTrader indicators trying to find the Holy Grail amongst muck.

But maybe it’s not the moving average that is the problem. Maybe it’s the way we have yet to quantify what makes one ‘good.’ Yeah, visually it looks pretty and we can tell. But what does that really mean?

Here’s the thing:

It’s usually a matter of proper framing of a problem that leads us to the solution rather than a well thought out chase. In fact, diverse and seemingly random solutions searched in a well structured harness often do better than hand tuned optimized single functions.

And so if you’re not spending a little bit of time thinking higher than your peers, you might just be wasting your time overall.

So let’s change that and follow me as I discover the next state-of-the-art moving average with nothing more than a good harness.

Overview of Moving Averages

The most rudimentary moving average of them all, the Simple Moving Average (SMA) was created by a guy named Udny Yule back in 1909 to analyze time series data. By the mid-1900s, traders were using it to read charts and determine trends. Early inefficient markets, especially commodity markets, could be traded with great profit using this simple indicator.

Soon enough however, as markets got more efficient, traders realized that the SMA lagged too far behind the price to be useful anymore. Researchers from other domains as well in engineering, transportation, sales forecasting, and more also needed something more accurate for their own applications.

In the 1960s, a trader named Pete Haurlan applied an exponential weighting function to the SMA to create the EMA, a superior function that addressed some of the issues of lag that the original function had.

While this was a vast improvement, it was not the end-all-be-all. In a few decades, trades were back at it asking how they could make an even better moving average function with even less lag and more smoothness.

In 2005 a trader named Alan Hull created his own flavor of the indicator named the Hull Moving Average (clever). It uses a sharper correction impulse to reduce lag, which works due to the fractal nature of the markets.

It captured the perfect blend of smoothness to reactivity.

Ever since, it has been hard to beat.

But the Question Still Persists…

The Hull Moving Average isn’t a crystal ball. It’s still a reactive, backwards looking function that only has as much market information as what you put into it. Of course it’s not going to be the perfect money maker.

For that, we need to set out to design the perfect moving average; one that improves upon the central problems of moving averages in general: lag, overcorrection, and noise indicating false trends.

And to Do That Requires The Oracle

We first need to ask the question of what a ‘good’ moving average is. We can look at a chart and say ‘yes that looks better than that one.’ But in optimization and programming land, that isn’t going to cut it. We need to figure out what that “feeling” is and quantify it into some numbers.

To do this, I decided to compare each moving average against a ‘perfect’ moving average. The functions that were closest to this ‘perfect’ function would score the highest and therefore be the winners.

How would I find this perfect moving average? And if I had one already why would I need to write this blog post?

Unfortunately, I do not have such a moving average. But, I do have a filter that looks into the future to paint a line backwards that is ‘perfect’ and we can use this as our oracle (our perfect example to compare against).

Such a function is pointless to us as traders who can’t see the future. But such functions exist and are used to decompose time series data to study underlying trends. I chose the Hodrick–Prescott (HP) Filter because it works the best for me and has strong support in economics research.

As you can see, the HP Filter captures that “feeling” we are looking for. Smooth, but still captures trends. Reactive, such that simply following the slope of the curve would lead to a profitable trading strategy. This is ideal.

The Comparatives

I employed three basic tests to score each moving average:

1. The Lag Test

   1. How much does a moving average lag behind the perfect oracle?

2. The Turning Point Test

   1. How well does a moving average react to changes in the trend?

3. The Trading Test

   1. How well does a moving average work as a basic single indicator trading strategy?

Each of these three test a different part of the function’s ability, giving us a wide sweep of metrics which we can use to generalize if one moving average is better than another.

Normalization

But first, I normalized each moving average. What do I mean by this? Well, rather than comparing HMA(9) to SMA(9), which both use 9 time steps, I wanted to compare the base function. A moving average could use more data and still spit out a curve that looks similar to another that uses less data. And so, fixing the window size for each function isn’t going to lead to a fair test.

I calibrated each function to find the window size that corresponded to the same smoothness as an SMA(50) function and used that window size for that function as the comparative default. You can read the code to see exactly how I did this.

Below are the values that were calculated for each of the baseline functions.

The Lag Test

Three symbols were used across three different markets: SPY, EURUSD, and GLD. Each function was swept across normalized window values from 8 → 96 and then the lag of each of those moving averages to the HP filter was calculated for each time step and averaged.

SMA generally performs the worst here which isn’t surprising given that it was the first function created for this task and all others attempted to improve upon it. Hull does second best to KAMA (Kaufman's Adaptive Moving Average) in this test.

The Turning Point Test

Turning points for all the symbols were calculated and the functions were applied. The confirmation delay and overshoot were averaged for every event aggregated together for each normalized timeframe. Lower confirmation delay means more reactivity of the function. Lower overshoot means the function doesn’t overestimate where the price is headed after the turning point.

In this example, we see that Hull squeaks out at lower timeframes on the confirmation delay, but comes in second to KAMA once again. But both Hull and KAMA pay for this reactivity by often overshooting drastically, which makes sense. You can’t have a free lunch.

The Trading Test

Finally, a simple strategy was simulated using each of the functions as the only indicator. Exposure for either a short-long portfolio (-1 → 1) and cash-long (0 → 1) was calculated by taking the slope of the curve applied to a rolling normalization function (tanh, clip, or rank). The result was 6 configurations per function and each function strategy only used their SMA(50) equivalent values (HMA(78) for Hull Moving Average).

Short-Long Results

This test is where Hull pulls away from the rest. It is especially good in non-trending or mean reverting markets, like EURUSD, and that gives it the leg up it needs against KAMA to pull ahead.

Long-Only Results

Similarly, long-only strategies, which generally are more stable, give Hull the advantage across both SPY and EURUSD. Hull is still performant on GLD, but does not pull ahead.

Final Scores

Taking all of the trading systems into account, Hull is the clear winner, nearly sweeping the board. That combined with its 2nd best performance against KAMA in the previous tests makes it the overall robust leader: it has the best performance with solid principles behind it.

Cool, But Where’s the Holy Grail

I said I was going to find the state-of-the-art and instead I just proved that Hull is pretty good. Right, but that is to set up this empirical harness so that we can throw any function at it and get a definitive score on how good that moving average is.

Now that the harness is complete, it is time to embark on quest to victory.

We already have our evaluation system constructed. All that is left is throwing arbitrary functions at it. So I need a source of arbitrary functions that are aligned to the task.

Per usual, I used an LLM to help me generate said functions. I first had it generate ‘families’ and then solutions under those families so that I could force a level of novelty and explore semantically different formulas than just ‘SMA plus this small change of detail’.

And while you may think that it is naive to just ‘spray and pray’ a bunch of functions from an LLM and see what works, the research actually says that novel and broad searches lead to better and more robust solutions than ones that are trained iteratively against a single optimization function. Click that link and read the paper for a fascinating brain blast.

361 Formulas vs. Hull - Round 1

Over 300 unique moving averages were developed. Each one was evaluated against the gauntlet and scored accordingly.

Note that different metrics describe different things. And so some metrics should be maximized while others minimized to calculate the score. For example, Sharpe should be higher, lag vs HP trend should be lower, etc.

You can see clear distributions around Hull with some beating them. But are those functions the same, or is one good at one metric and terrible at the rest? To determine this, I plotted the elites (best overall candidates) and marked them in squares against the baseline circles below.

The elites clearly cluster around Hull and beat it in some cases. Let’s look more closely at those elites and toss out the rest.

8 Formulas vs. Hull - Round 2

For this round, I used larger price datasets from EODHD (who graciously give me complete access for free, so check them out. They are my go-to data source due to their ease of use and value. Use my affiliate link so they know I sent you.)

I then employed the following tests:

• Test A — Unseen history. EODHD daily data 2000 → mid-2021: two decades the stage-1 ranking never touched (used daily up to current day), across six assets (SPY, QQQ, IWM, TLT, GLD, USO) — dot-com bust, 2008, the 2010s bull, the 2020 crash.

• Test B — Parameter sweeps. The full (smoothness × slope-window) Sharpe surface, scored by its plateau (robustness), not its peak; plus the cost capacity curve — at what transaction cost does the edge die?

• Test C — Strategy construction. Three strategy templates (continuous slope-sizing, fast/slow crossover with hysteresis, multi-timescale ensemble) — an MA that wins as a slope signal can lose as a crossover system.

• Statistical honesty. Block-bootstrap confidence intervals on every headline Sharpe, because a 21-year point estimate still has error bars.

• Transaction fees are modeled at 5 basis points.

Test A

The Stage 1 trading strategy simulation was recreated and transaction fees were applied. Each function was averaged across a 6-asset portfolio and the tanh long-only slope rule was used, as it showed the most stability across all the function previously as a trading strategy test.

Reflux came out as the winner on Sharpe with total return.

Test B

The Sharpe ratio was calculated on average for every function at different transaction costs to see which ones held up the best against fees. Reflux did the best here, maintaining performance across the board besides early on from fees up to 5 basis points.

Below is a sweep of the Sharpe surfaces for each of the elites where higher general Sharpe ratios in all cases means more robust performance of the function.

Reflux is the clear winner here again with plateau reaching 40% meaning that it is highly robust in all cases.

Test C

In the strategy construction test, we again see Reflux as the winner on both continuous slope-sizing (Stage-1 strategy test) and a multi-timescale ensemble to test variability of each function.

Final Scores

Reflux beats Hull in 5 out of 6 tests, more than all other elites, making it the clear winner. This proves that the harness works and that we have a truly better function out there.

But I had one last test to make. Can we use Reflux as a drop in replacement for an existing strategy? This would be the ultimate test to see if we have an actual useable function for making money.

Replace EMA for Reflux to Make OLMAR Even Better

Awhile ago I implemented the "On-Line Moving Average Reversion" (OLMAR) portfolio selection strategy which does very well when applied across large baskets of assets on a daily trading basis.

The moving average used in that algorithm is the Exponential Moving Average. So, if Reflux really is better, I should be able to pop it out and get better results, right? Let’s see how it worked.

With just a function simple replacement, Reflux improved OLMAR by a massive leap forward. We maintained the same risk profile (maximum drawdown) while gaining a 33% increase in CAGR (which is insane).

On 0.2x leverage to reduce downside risk, we still see a massive improvement over the original OLMAR strategy. This goes to show that a good evaluation system and harness go a long way when it comes to function optimization and research.

And Moving Forward

So you can go ahead and take the Reflux Moving Average if you’d like and apply it to your own strategies. But what you can also do is apply the concept of good evaluation system construction to then find new solutions to age old problems. In the era of AI, this is becoming the way forward, especially in research.

I don’t see that stopping any time soon, and you know for certain that people making 3x your salary sitting in a skyscraper in Manhattan are having their bosses shove AI mandates down their throats. You might as well start competing.

Get the Code

Get the Reflux Moving Average along with the other 360 functions to supercharge your trading journey in the subscriber Google Drive.

Open Drive

All of the code to reproduce the experiments here are also included in the Google Drive for paid members.

Not a paid member yet? No worries.

Subscribe now to get access to this posts code and all of the previous code for all other posts. Not only does it add value to your own trading journey, but it helps support me on my own as I educate you on complex systems in a simple and easy to digest way.

Consider it. Hope to see you soon, and like always, happy trading!

Stuart

What if you didn’t have to research anymore to make money trading? What if with the right system, you could teach an agent how to research for you while you sit back and rake in the dough?

That’s the reality of autoresearch systems like ShinkaEvolve that automatically improve themselves without any human intervention. It sounds like sci-fi and the end of humanity. But, it’s just the beginning to a new Renaissance of knowledge.

And the thing is,

If you aren’t quick to adopt this new technology, you’re going to be left in the stone ages behind massive firms and savvy quants who do.

So let’s dive into how I did it, and so can you.

What the Hell is Autoresearch

Like the name suggests, autoresearch is a system that self-improves a problem over time by researching alternative solutions and making adjustments. There are many that exist, but I’ve found that ShinkaEvolve from Sakana.ai works best for me.

The key distinction here is that an autoresearch system uses LLMs to self-improve. There is a specific ‘harness’ or piece of code that can evaluate any solution the LLM spits out and the LLM attempts to return a piece of code that can beat the current winning program.

So, it’s kind of like an internal competition. Different systems use different approaches. ShinkaEvolve uses the concept of ‘islands’ and ‘innovation sampling’ to seperate solution families into clusters and to dynamically inject ‘innovations’ into the LLMs context / prompt so it can use what it has discovered in the past.

This is surprisingly effective and has shown to find state-of-the-art solutions to not only demo problems like circle packing (seen above), but also industry relevant solutions like new AI primitives, optimizers, and network configurations.

Ok, but what about the money?

And so, how do we use this thing to make us money? We need to just provide the files that ShinkaEvolve needs, but make it so that it’s evolving portwine (repo here) strategy classes rather than circle packing solutions. Below is the basic flow of initialization:

So, I took my OLMAR trading strategy (from this blog post) and added # EVOLVE-BLOCK-START and # EVOLVE-BLOCK-END in the code to let the autoresearcher know what we want changed.

Then, I wrote an evaluator that just imports this class, runs it on a set of dividend bearing stocks, and returns a combined score, which becomes the score we want to maximize.

score = cagr \  # primary score
  + 0.35 * excess_cagr \ # add a bit extra for excess
  + 0.10 * sharpe \ # add for uniformity of returns
  - 0.20 * abs(max_drawdown) \ # penalize drawdown
  - 0.03 * mean_turnover # and turnover

Finally, I wrote a rich context file for the system to use to understand my backtesting library, portwine (repo here), what it’s trying to do, and some suggestions on initial search spaces.

From here, the system will take over and do the following:

Running the Autoresearcher

Now that I had my problem in place, all that was left was running the autoresearcher.

ShinkaEvolve comes with a nice web UI. When you run it, you can start to see the lineage of the solutions. There is a clear path to generation 224, the best solution evolved.

You can also visualize the progress over time. You can see the earliest gains were at the beginning. But, even 250 generations later, there is still steady improvement in the Cumulative Mean which suggests that over a long enough time, it could find even better solutions.

The original OLMAR solution had a CAGR of 16.64%. This new one has a CAGR of 24.74%, or a 50% improvement on the baseline and 2.5x improvement in combined score. Truly incredible.

Subscribe now

Inspecting the Lineage / Progression of Solutions

While I ran this for about 250 generations, the ‘winner’ follows a lineage path. And so, we can look at each child from the original strategy up to the winner to understand what innovations it learned along the way.

Initial Program - gen_0, 0.112

Obviously, this is the default program. But let’s breakdown the innovations that this system has which makes it work so well:

Innovations:

• Mean Reversion Forecast - A simple way of asking whether a stock has fallen below its recent norm.

  • Rational: If a stock’s current price is below its recent average, it may rebound back toward that average. This is easy to compute and works surprisingly well in slower, steadier baskets.

• Passive-Aggressive OLMAR Update - A measured rebalancing rule that nudges the portfolio toward better opportunities without rebuilding everything from scratch every day.

  • Rational: Rebuilding the portfolio from scratch every day would be unstable. OLMAR keeps the portfolio adaptive without making arbitrary jumps.

• Simplex Projection - A clean-up step that makes the portfolio valid again: no negative positions, no hidden leverage, and all weights still add up to 100%.

  • Rational: Raw weight updates can produce invalid portfolios with negative weights or totals above 1.0. A practical strategy needs to stay within realistic portfolio constraints.

• Missing-Data Handling - A safeguard for stocks that do not yet have enough history.

  • Rational: In the 32-name basket, some names enter the dataset later than others. The strategy should not make decisions from incomplete or unreliable history.

Great! And now, let’s quickly continue through the rest of the models:

Hybrid OLMAR Regime Low Turnover - gen_11, 0.112 → 0.200

Innovations:

• Regime Detector - A simple market-state check for the basket. The strategy first decides whether conditions are broadly bull, mixed, or weak.

  • Rational: Pure OLMAR assumes most dips are temporary. That works in some conditions, but not when the whole basket is weak. The strategy needed a way to reduce risk when the broad environment deteriorated.

• Multi-Horizon Median Momentum - A trend signal that looks at short, medium, and long windows instead of just one.

  • Rational: One window can be noisy. Multiple windows create a more balanced picture of whether a name is genuinely improving. Using medians also reduces the impact of price spikes and outliers.

• Realized Volatility Scaling - A rule that gives calmer stocks more trust and noisier stocks less trust.

  • Rational: Two stocks can have the same raw signal, but the noisier one is usually a riskier bet. The model needed a way to reward steadier names.

• Sleeve-Aware Boosts - Grouping stocks into meaningful buckets like healthcare, staples, energy, and duration.

  • Rational: The basket is economically structured. Some groups are naturally more defensive and deserve more attention when conditions weaken.

• Scheduled Rebalance And Smoothing - The portfolio does not fully re-optimize every day. It rebalances on a schedule and only moves partway toward the target.

  • Rational: Better signals can still produce bad portfolios if the model trades too often. Turnover needed to be controlled once the strategy became more sophisticated.

• Duration And Cash Fallback - A safe place for capital when stock conditions are poor.

  • Rational: The baseline had no explicit defensive destination. A defensive basket still needs a proper risk-off mode.

• OLMAR Retained As A Conservative Correction - The original OLMAR logic still exists, but as a supporting layer instead of the main engine.

  • Rational: The seed was already good enough that it made sense to keep its strongest part. The goal was to wrap OLMAR with better portfolio logic, not discard it.

Hold on. This is worse. Why is this in the lineage?

Although the total returns are worse in this example, the actual score is better. It has a much higher sharpe ratio and a much lower turnover which means this allocator is a lot better than OLMAR. Also, the innovations here will be improved in further generations.

Hybrid Defensive OLMAR Crossover - gen_17, 0.275 → 0.288

Innovations:

• EWMA-Smoothed Regime Detector - A smoother version of the regime detector that averages recent basket readings instead of trusting the latest one too literally.

  • Rational: A raw regime signal can flip back and forth near the cutoff. That creates whipsaw: too many defensive shifts and too many false recoveries.

• Adaptive Equity Sizing By Cross-Sectional Volatility - A rule that automatically reduces stock exposure when the basket becomes more unstable.

  • Rational: Even a correct view on direction can still be too risky if volatility jumps. The portfolio needed a way to scale down when the environment got more chaotic.

• Top-K Relative-Strength Selection - The strategy only funds the strongest candidates instead of spreading capital across every barely-positive stock.

  • Rational: Once the basket is ranked, broad allocation across weak names can dilute the signal. Concentrating on a small leader set gives the signal more impact.

• Per-Day And Per-Rebalance Turnover Limits - Hard brakes on how much the portfolio can change in one day or one rebalance.

  • Rational: A better model can still be a worse portfolio if it trades too aggressively. The lineage needed stronger execution discipline.

• Volatility-Damped OLMAR Nudges - The old OLMAR correction still exists, but it becomes smaller when markets are noisy.

  • Rational: OLMAR still has value. But in volatile periods, strong reversion nudges are more likely to create churn than help.

• Better Defensive Sleeve Behavior In Weak Regimes - A stronger shift toward safer groups like healthcare, staples, and duration when the basket weakens.

  • Rational: In this universe, weak conditions often call for “more defense” rather than “all risk off immediately.” The strategy needed a better middle ground.

Hysteresis Drawdown Sleeve Caps - gen_106, 0.275 → 0.288

Innovations:

• Entry And Exit Hysteresis - A rule that requires repeated evidence before buying or selling, instead of reacting to one positive or negative day.

  • Rational: Even a smoothed signal can still flicker around the threshold. The strategy needed more patience before changing positions.

• EMA Trend Confirmation - A second check that asks whether price is still behaving well right now, not just whether the slower momentum signal looks positive.

  • Rational: A stock can look good on a slower signal while already rolling over locally. The model needed a local trend filter before committing new capital.

• Sleeve-Level Cap And Residual Routing - A cap on how much of the portfolio can sit in one broad group like healthcare or staples.

  • Rational: Per-stock caps do not stop the portfolio from becoming too concentrated in one theme. The strategy needed true diversification, not just “many names.”

• Longer Hold Time And Slower Rebalance Cadence - The strategy trades less often and gives positions more time before reconsidering them.

  • Rational: By this stage, the biggest gains were coming from stability and selectivity, not from more frequent reacting.

• Tighter Daily And Rebalance Caps - Smaller limits on how much the portfolio can move at once.

  • Rational: Strong models can still perform poorly if they swing the portfolio too hard. The search found value in forcing the portfolio to earn the right to move.

• Earlier Drawdown Throttle - A faster defensive reaction when the portfolio starts to weaken.

  • Rational: Waiting for deep drawdowns can be too late. Earlier risk reduction is often more valuable than fully chasing every rebound.

• Lower Single-Name Cap - Capping the maximum percentage of the portfolio that any one stock can occupy. In plain English, it stops one position from becoming so large that it can dominate the whole portfolio.

  • Rational: The strategy was already finding good names, so it no longer needed oversized bets to perform well. At that point, diversification mattered more than squeezing extra upside out of one stock.

Drawdown Aware Inertia - gen_134, 0.275 → 0.288

Innovations:

• Per-Asset Peak Tracking- Each stock remembers its own highest recent level.

  • Rational: A portfolio can look stable overall while one holding has quietly become very damaged. The strategy needed a way to detect stock-specific deterioration, not just basket-level weakness.

• Local Drawdown Score Shrink - A penalty that reduces a stock’s attractiveness if it has fallen too far from its own peak.

  • Rational: Mean-reversion logic can keep chasing “cheap” names that are actually just collapsing. Basket-wide drawdown control alone cannot prevent that mistake.

• Dynamic Turnover Cap By Regime And Stress - A turnover limit that changes with conditions instead of staying fixed.

  • Rational: The right amount of trading depends on the environment. In strong conditions you can allow somewhat more flexibility; in weak or stressed conditions you usually want more inertia.

• Further OLMAR Damping In Weak Or High-Volatility Conditions - The OLMAR-style mean-reversion push is weakened or shut off in the wrong environments.

  • Rational: OLMAR works best in calmer pullbacks. In highly unstable conditions, stronger reversion pushes often increase churn more than they increase returns.

Persistence Score Threshold - gen_224, 0.275 → 0.288

Innovations:

• EMA Persistence Gating - A way to check whether a stock’s positive behavior has lasted for a while, instead of trusting one good reading.

  • Rationale: Many bad entries come from short-lived bursts that disappear quickly. By this point in the lineage, the problem was not missing obvious winners. It was letting in too many fragile candidates.

• Momentum Plus MAD Thresholding - A stronger entry hurdle that requires a stock to be clearly stronger than the pack, not just slightly positive.

  • Rationale: In weak or noisy markets, many stocks can look mildly okay at the same time. A simple “positive signal” rule is too loose in those conditions.

• Lower Single-Name Cap - Capping the maximum percentage of the portfolio that any one stock can occupy. In practical terms, it prevents the portfolio from leaning too heavily on a single company.

  • Rationale: By this point, the strategy was winning through better selection and better risk control, not by making huge bets on one name. That made large single-stock positions an avoidable risk rather than a necessary source of return.

• Longer Hold Period - Once a stock earns a place in the portfolio, it is given more time before the strategy considers changing it.

  • Rationale: If the model is already working harder to admit only durable names, it makes sense to let those names stay longer. Otherwise the portfolio can still overtrade after all the work done to improve entry quality.

• Smaller OLMAR Aggressiveness - The old OLMAR reversion overlay is still present, but it has less power than before.

  • Rationale: The final winner is mostly a robust tactical allocator, not a reversion-first model. Too much OLMAR at this point would bring back the churn the lineage spent many generations removing.

• Turnover Throttle When Persistence Is Weak - A rule that tells the strategy to trade less when too many stocks have weak, fragile signals.

  • Rationale: If persistence is weak across the basket, signal quality is low. When the model is less confident, the right response is usually to slow down, not trade harder.

The Final Verdict - A Completely New System

The final evolved solution deviated greatly from the original OLMAR. Instead of a single mean-reversion type system (as OLMAR implements), Persistence Score Threshold uses cross-sectional allocation, momentum, and market regimes.

Stocks are put into ‘sleeves’ or categories based on their industrial sector and weights are applied to those sleeves rather than the individual stocks uniformly. This allows a more rich ‘defensive’ versus ‘offensive’ model that adapts based on the overall market volatility and performance. For example, defensive groups like healthcare and consumer staples emerge as groups of stocks rather than just one.

Within the sleeves, weights are allocated to the better performers- high momentum, low volatility. There is forced diversification through single stock allocation limits which helps against downside variance.

To further limit risk, TLT and SHY are put into a pure ‘cash-like’ sleeve which is used to pull out of the market when nothing is performing.

Turnover is discouraged with weekly rebalancing, position smoothing to prevent rapid changes in positions, and a cap that tightens when the performance is doing well and loosens when it is doing worse.

Using a Slot Machine to Squeeze out 20x More

To further optimize, I used an algorithm called Thompson Sampling which behaves somewhat like a slot machine to sample changes and learn which modifications are best over time.

Thompson Sampling builds probabilities for different states and actions given feedback from trying out different combinations. This then builds a model to map an action or state to an expected result. The state / actions we have here are the parameters of the strategy. The result is our objective function, which I used the Surefire Ratio for, but can be CAGR, Sharpe, whatever.

I first defined the state my system could be in such as the list of tickers being used, the rebalance time, and all the other variables.

"params": {
  "bear_boost_duration": 1.6,
  "bear_boost_energy": 0.75,
  "bear_boost_healthcare": 0.95,
  "bear_boost_staples": 0.95,
  "bear_boost_yield_sin": 1.1,
  "drawdown_cutoff": 0.1,
  "enter_persistence": 0.6,
  "eps": 14.0,
  "max_rebalance_turnover": 0.14,
  "max_single": 0.06,
  "neutral_boost_duration": 0.95,
  "neutral_boost_energy": 1.0,
  "neutral_boost_healthcare": 0.95,
  "neutral_boost_staples": 0.95,
  "neutral_boost_yield_sin": 1.2,
  "rebalance_alpha": 0.2,
  "rebalance_every": 21,
  "residual_duration_share": 0.9,
  "turnover_drawdown_multiplier": 0.75,
  "turnover_drawdown_threshold": 0.15,
  "turnover_floor": 0.45,
  "turnover_weak_frac_scale": 0.35
  "basket": [
      "ABBV", "ABT", "AMGN", "BMY", "CL", "CLX", "CVS", "CVX", "GILD", 
      "GIS", "IBM", "JNJ", "KHC", "KMB", "KO", "LLY", "MCD", "MDLZ",  
      "MMM", "MO", "MRK", "PEP", "PFE", "PG", "PM", "SHY", "STZ", "T", 
      "TLT", "VZ", "WMT", "XOM"
  ],
}

Each of these parameters has a discrete set of options it could be. So eps is not just a continuous variable. I choose from a list of numbers like [10.0, 12.0, 14.0, 16.0, 18.0, 20.0] to select one. This is done as well for 32 stocks in my basket, and the rest of the parameters I want to test.

And, like playing a complex chord on a piano, the sampler runs a ton of trials and begins to learn the best combinations of ‘notes’.

So, I gave it a run of 2,500 trials after a few tweaks to make the sampler work better for me and my specific purpose. And, lo and behold! Even more performance. Below is the comparison between the default parameters for the Persistence Score Threshold, gen_224 strategy and the optimized version.

The universe selected used SP1000 tickers from 2018. With this simple sampler (hah), we were able to juice out 20x performance. Add that to the 50% increase from the OLMAR system to this system, and we’re at a cool 30x all while making the machines do the work.

Nice.

Where to Go From Here

And so, it’s obvious that autoresearch with a bit of concise machine learning can really improve our quant systems.

What that means for you is that you need to start getting familiar with these systems as soon as possible. Download the code to this article. Reproduce the results. Make it learn on one of your own systems. Optimize it even further.

The possibilities are limitless, as is the opportunity for you to make considerably more from your existing work.

Ready to Build? Download the Code Now:

Download the Code

Have a Founder’s / Professional Account? Download all 250+ systems instead of just the 5 shown here:

Download all 250+ Systems + Optimizers

Don’t have access to the Google Drive? No problem, become a paid subscriber and get access instantly to the systems written about in this article and the ShinkaEvolve environment so you can run it yourself.

Professional Member accounts get access to the full unfettered system runs (all 250, not just the 4 in this specific lineage) and the custom Thompson Sampler algorithm I wrote which increases novelty and exploration to find systems that are uncorrelated.

Thank you to everyone who currently supports me. You enable me to continue doing this and providing you with state-of-the-art quant research translated into easy to digest articles, code, and examples that you can use out of the box in your own research.

As always, happy trading!

We all have a friend who has a gambling ‘system’ that we just roll our eyes at because it’s bound to lose. And sure enough, three weeks later he comes back to admit he’s lost it all.

But what if I told you that amongst this class of ‘fool’s errands’ lies some gold after all? Here’s how I took the classic Martingale betting strategy and turned into a consistent winner.

Here’s the thing:

As much as we hate it, illogical hypotheses can be true. I took a complete loser of a concept into something that is a winner and you can too.

How much is your pride making you lose? Join your friend on the other side. Just do it in a mathematical and provable way before betting your life away.

What Even is Martingale?

We’ve all seen ourselves or our friends in a situation where we look at each other and ask ‘double or nothing?’ when we’ve just lost a bet. Which is the exact strategy of one of the oldest gambling ‘strategies’ of all time.

Called Martingale, the system is just to double up on a bet when you lost because you think you’ll eventually win. This is applied generally to binary bets like roulette (red or black, which pays around 1:1).

Everyone knows this is a gambler’s folly. But what if I told you, by some ridiculous notion of the universe, that these systems can and do work under certain circumstances in a generalization way that is easily applicable to your own trading systems.

But there’s one thing we’re missing:

Martingale Alone Doesn’t Work

You walk up to the roulette table. The last 5 spins have been black.

⚫️🔴🔴⚫️🔴⚫️⚫️⚫️⚫️⚫️ ❓

“It can’t be 6 blacks in a row, right?” You bet $5.

⚫️🔴🔴⚫️🔴⚫️⚫️⚫️⚫️⚫️ ⚫️

Wrong.

Yes it can. The ball lands on black for a 6th time. The operator takes your money.

⚫️🔴🔴⚫️🔴⚫️⚫️⚫️⚫️⚫️⚫️ ❓

“But surely it can’t be 7.” You bet $10 to make up your previous loss and then some.

⚫️🔴🔴⚫️🔴⚫️⚫️⚫️⚫️⚫️⚫️ 🔴

You were right. The ball lands on red and you walk away with your $5 back and an extra $5 for a total of $20.

What could go wrong? This sounds like easy money. So you start over, this time with that $5 you just made, doubling each time, and slowly grinding your stack up. Sure enough, you end up making a pretty penny because you are lucky. Although this strategy works well in the short term, it can catastrophically fail when doubling your money becomes astronomically expensive versus the payoff. In fact, I’ve lost $500 at a $1 electronic roulette table in a crappy Vegas casino in the matter of 5 minutes. On the first night there.

“Alright, easy lesson,” you think. “It’s the cost of learning how to play.” But surely this is just a beginner’s lesson, right? Surely this isn’t a multi-million dollar industry of scam trading strategies, right?

Millions are Wasted on Scam Martingale Strategies

In the world of trading, everyone wants one thing: to do nothing and make money. So for the suckers who believe that people would sell their solution for a few hundred bucks that could net them millions… I’m sorry to break it to you, but 99% of these things are scams.

Most of these systems can be found in the FX space, specifically around sketchy B-Book brokers and the MetaTrader ecosystem. They fool people with the near linear equity curve as many tracking sites like MyFXBook are not incentivized to provide ultra clear insights.

Example Strategy Found on MyFXBook

Corresponding Strategy Landing Page (Name Omitted)

These systems work generally by using a mixture of Martingale and Grid Trading, which means they set pending limit orders at different price points around the current trading price. Each order has a fixed stop loss and take profit (usually 1:1 and scaled with risk for that binary win).

When an order is filled, the other’s are cancelled and the trade rides. If you win, nice. If you lose, double up and try it again.

Spoiler alert — the same thing happens as it does in the casino. Usually these systems work for a certain amount of time and in certain market conditions but blow up when there is a high string of losses.

Defying Logic and Making Money Anyways

What if we defied the gods of logic and probability? What if we bought into the hype that millions could be made from thin air, paid to us by the house willingly? What if Martingale systems can work?

Now you’re thinking like a real American.

So I built an experiment harness that accepted a MartingaleStrategy class in which market data would be streamed into it.

My MartingaleStrategy classes will be alternative approaches to the betting system. Instead of just fixing a stop loss and take profit levels, I came up with a ton of different hypotheses. For example, does the momentum of the market make things better or worse? What about dynamic stop loss and take profit scaling? Different risk to reward ratios?

Our Baseline - Standard Martingale on QQQ

Our control strategy, or baseline strategy, will be simply going long on the QQQ with a fixed take profit and stop loss. I’ll run a parameter sweep on a bunch of different percentages to give us a good portfolio of systems and compare them to just buying and holding QQQ.

So, let’s first check out this chart. We must support leverage (I cap it at 10x here) because a Martingale bet must return a binary win. Meaning, if our stop loss and take profit levels are 1% away, and we start with a $100 bet, we need to scale our risk such that we either make or lose that $100 bet when the stop loss or take profit is hit.

That means controlling a position worth $10,000 ($100 / 1%). Martingale systems are usually run on FX intraday markets because of the high leverage opportunities available to retail clients.

Anyways, if we are meant to believe it, with 10x leverage available, we actually are more capital efficient with a Martingale system than buy and hold (if we know the best parameters beforehand). Let’s see if we can scale this up.

Scaling Up - Other Strategies

So this is what we have to beat.

I created an entire suite of attempts- different betting schemes, different entry schemes, looking at momentum, regime change, volatility, blah blah blah… and by the grace of God… Here’s what I found:

Fibonacci Martingale

Utilizing the Fibonacci sequence into our risk taking and targets, we achieve lower drawdown and higher returns than our Naive Martingale in the Best Run.

D’Almbert “Martingale”

An alternative betting system to the classic Martingale by the mathematician D’Almbert (who would have thought). It uses addition and reduction rather than multiplication. The variance is wild (my sweep is also large), but it indicates much better capital efficiency than buy and hold in certain situations.

Return Skewness Martingale

And here it is, the Magnum Opus of my research. Here is a Martingale, that by some grace of literal God, gets a higher Sharpe ratio and usually outperforms the QQQ on average if you just pick some random parameters.

Aggregate and diversify across all 288 strategies, and your performance will outperform the QQQ, be in the market for less time, and have 10x the capital efficiency.

And so it looks like we did it. We really did make Reagan proud and accomplished the American Dream: doing what people say is stupid and impossible just to rub it in their faces.

Scaling and Expanding to Other Markets

So, now what? Well, I’ve clearly demonstrated that Martingale systems can work if they are coming at the problem in a new and innovative way. But where does that leave us?

That leaves us with you taking this knowledge and applying it to your own trading. Read the code, download the notebook, try it with other assets, make your own Martingale.

But most importantly, don’t let the nay-sayers tell you that it’s impossible. The most stupid ideas are often the ones no one has checked on in a while.

If you want to play around with the code, check out the Google Drive now. You get 18 Martingale Strategies versus the 3 discussed here to start your research journey:

Martingale Notebook

If you don’t have access yet, become a paid member for just $20/mo and get access to this and all the other code for all my other posts, free for you to use in your own strategies and research.

Subscribe now

Go make something great. Reagan and I believe in you.

~ Happy trading.

Often we have a trading system with a countless number of trades (in my case 70,000,000) with little to no way to understand actually what is going on. Sure, we get massive printouts and tear sheets with a ton of figures that quantify our strategy. But, what about on a trade-by-trade basis?

What we really need is to understand the quality of our trading systems on a trade-by-trade basis. It’s better to have a system that has super high efficiency, mastering entries and holding for minimal time than one that takes out trades haphazardly and holds for long periods of time, keeping our capital locked up and at risk.

So rather than using the “same old same old,” I devised a trade quality scoring system so that you can drop in your trades and figure out if they are good, how to improve them, and how to make more money than your peers in the marketplace.

Here’s the thing:

Aggregate strategy metrics are great, but they lack the granularity which can give us clear insights into exactly how our strategy works.

Without these trade-by-trade metrics, you won’t be able to construct and optimize the perfect strategy for your given needs and you’ll be left with unsatisfactory results.

Defining High Quality Trade Metrics

There are many metrics that already exist in terms of ranking a trading strategy: Sharpe ratio, Sortino ratio, maximum drawdown, CAGR, etc. But these are big picture metrics.

There also exist lesser known metrics that are made to give a deeper and more granular look into how each trade bar by bar is performing. Let’s dig into several of them to see how they work and give us a better picture into our work.

Measuring Opportunity Capture with Maximum Adverse/Favorable Excursion (MAE / MFE)

Every trade has a maximum point at which you as a trader feel the most pain. This point is known as the Maximum Adverse Excursion (keyword ‘adverse’). We measure this by taking the maximum potential drawdown of a trade, even if the trade didn’t end in the red.

Below is an example:

We take out our trade, and it moves against us a maximum of -4.58% (thus it is our Maximum Adverse Excursion). However, the trade still closes in the profit. It’s a good trade, right? Well, what if that number was -8%? -10%? What is your risk model? The MAE here gives us a signal into that on a trade by trade basis so we can find which strategies are the riskiest, and potentially even modify our stop losses.

On the inverse, we have the Maximum Favorable Excursion. And, this is exactly the opposite of the MAE. We can see the maximum point that the trade moved in our favor.

But wait, why would we want to do that? Well, there are cases, like the one below, where our trade could have made more money, but our take profit logic didn’t get us 100% efficiency.

So, while a high MFE can be good, it’s bad if the difference between the MFE and final returns is large as it tells us that at the trade was not efficient.

Here I am filtering out the top 50 trades on AAPL using the Ichimoku Cloud stop loss I developed ranked by MFE / return.

As you can see, this gives us the top trades where the MFE is not far away from the final returns, which selects only the ones that are continuously in profit.

Measuring Trade Smoothness with Monotonicity

It sounds like a mouthful, but monotonicity describes how monotonic a function is. A function is monotonic when increasing values on the x axis result in continuously increasing or decreasing values on the y axis.

Functions that squiggle up and down like a sine wave are not monotonic. This works great for us because trades should be monotonic (have a drawdown of 0%!) Of course, this is impossible. But, we can describe this monotonicity and filter out trades that are non-monotonic to a certain degree.

Monotonicity is simply defined by taking the difference of a time series, and counting the number of resulting bars that continue the up or down trend and then dividing that count by the length of the time series.

So, if a trade of 20 bars goes up straight for 5 days, then down for 5, and then up for 10, we take 5 + 10 / 20, or a monotonicity of 75%.

Here are the top 50 trades selected by monotonicity. Notice how unlike the previous graph, there is much more regularity on a comparative trade by trade basis. This comes at the cost of final returns (aka risk vs. std deviation of returns).

You take less risk when optimizing for monotonicity, but at the cost of potentially more returns.

Measuring Psychological Pain with Ulcer Index

The Ulcer Index is a measurement that captures on average how much a trade is under water on a step by step basis. We can use it to minimize how much psychological pain we are in as we watch our trades progress.

It’s calculated as so:

1. Taking entry and exit prices and turning that into a running equity curve.

   1. Prices: $1.00, $1.05, $1.03, $0.98, $1.01, $1.00, $1.10

   2. Running Equity: 0%, +5%, +3%, −2%, +1%, 0%, +10%

2. Walking through each point and tracking the maximum peak so far.

   1. Running Equity: 0%, +5%, +3%, −2%, +1%, 0%, +10%

   2. Peak so far: 0%, 5%, 5%, 5%, 5%, 5%, 10%

3. Doing the same, but tracking drawdown so far:

   1. Running Equity: 0%, +5%, +3%, −2%, +1%, 0%, +10%

   2. Drawdowns (value − peak): 0%, 0%, −2%, −7%, −4%, −5%, 0%

4. Squaring and summing the negatives:

   1. Drawdowns (value − peak): 0%, 0%, −2%, −7%, −4%, −5%, 0%

   2. Square negatives: 4, 49, 16, 25 → sum = 94

5. Averaging the sum over the length of the trade:

   1. Sum: 94

   2. Average over length of trade (7 periods): 94 / 7 ≈ 13.43

6. Taking the square root of that average:

   1. Average over length of trade (7 periods): 94 / 7 ≈ 13.43

   2. Square root: √13.42857143 = 3.66450153

A high Ulcer Index means that our trade moves against us more often than a low Ulcer Index. So, our goal is to minimize the Ulcer Index.

Here are the top 50 trades selected by lowest Ulcer Index:

You can see similar results to the monotonicity trades, which is good! Most of the time we want to optimize our strategies for consistent returns rather than risk, as we can simply leverage our systems in most cases.

Combining What We Learned into Categories

Each of the three metrics above deal with different aspects of what makes a trade ‘good.’ There is no objective ‘good.’ That is known. What we need to know is how a trade scores on different aspects of this ‘good.’

So, I came up with 5 categories of quality that we can measure:

1. Execution Efficiency

   1. “Exit capture,” or realized returns / maximum favorable excursion.

2. Risk & Pain

   1. Optimized Cumulative Distribution Function via Box-Cox on Ulcer Index to scale from a logarithmic distribution → 0 - 10.

   2. Trained on a distribution of 8.8 million trades.

3. Smoothness

   1. 0 → 10 given the monotonicity of a trade.

4. Risk-Adjusted Return

   1. Optimized Cumulative Distribution Function via Box-Cox on Exit Returns / abs(Maximum Adverse Excursion)

   2. Trained on a distribution of 8.8 million trades.

5. Psychological Comfort

   1. Percentage of time the trade is in profit (above entry price) scaled from 0% → 100% to 0 → 10

You can drop in any of your trades whether you have the prices or the returns and get out a radar chart that scores the trade based on these metrics:

Not bad. This does seem like a ‘comfortable’ trade, while it is still very choppy and has some risk. So, the radar plot works.

Creating a Composite Score and Ranking all Trades

Finally, I calculated the area of the pentagon for each radar calculated on each trade. This gives a final ‘radar score’ which I can then use to sort a list of trades.

Furthermore, if you noticed the first few graphs, the lines looked very similar. This is because there are a lot of trades that have the same exit day, but slightly different entry days. This skews the data and gives us ‘non-unique’ points in the equity curve.

I created a simple filter to group trades by that exit bar and to select the best trade for each. This filter works because this analysis used a single stop loss (Ichimoku Cloud) different trigger points for entry. When comparing all of my stops, I will only run this filter for each stop loss.

Here is the resulting graph:

And here are those 50 trades plotted on the AAPL equity curve (log-scale on the y-axis):

You can see clearly how this metric is capturing the best ‘upward’ points. The challenge now is figuring out how to take the trade at that entry point (our favorite part!).

Next Steps

Now with some clear metrics, we can rank our trades by quality and pick the ones that do the best, period.

The next challenge with this project is to figure out what entry signals map best to these points. Perhaps by creating an aggregate ‘radar score’ across all trades given a stop loss and feature combination? Perhaps using a decision tree? Perhaps by looking at the raw feature values to see if they have some sort of correlation to these periods of time? The sky is the limit.

But what is clear is that you now have a better grasp on what trade quality actually is. If you want the full code to recreate the findings here, you can purchase it from Gumroad here:

Go to Notebook

Stay tuned until next time as we progress this project forward and research more into this massive Big Data project.

Happy researching!

Apologies on the long hiatus (I didn’t post last week). I started this project with a simple idea which spiraled into a massive problem of optimization, parallelization, data analysis, blah blah blah, which was fun- but took 10x longer than I thought. Anyways, enjoy part 1!

In a previous article, I developed a suite of new and novel stop loss algorithms and rated them on how effective they were at being good stop losses. I found that not only were some clearly better than others, but some were actually universally good as signals in general.

Which got me thinking… we tend to focus on the entry conditions of a trade first. But what if instead, I used the outcomes of all my stop loss data (39,445,340 trade simulations across 59 stop losses, 8 symbols, simulating a long and short every day since 2000) as labels for features?

Then, I would be working backwards. And with the targets already known, I could just throw a soup of indicators and features at the wall to see what sticks (sarcastically). Realistically, however, with proper validation, this method could allow me to data mine features for just about any asset I want.

Here’s the thing:

Sometimes working backwards makes sense. Sometimes esoteric or strange approaches to a problem are what solves it. Novelty, and setting up a clear system to churn through massive amounts of data, can lead to a data pipeline which prints alpha.

And here’s how I did it.

Beginning with 39 Million

The state of the art is this: 39,445,340 trade simulations were made with 59 stop loss types and various numbers of parameters (ATR stop w/ window 14, ATR stop w/ window 30, etc) and across 8 symbols.

I took a trade out everyday and let it ride with each stop loss / parameter to get basic statistics and to determine which stop losses performed the best. Things such as time in market and total return were recorded.

It’s important to remember that in my last post about stop losses, I was measuring the stop loss efficiency which a bit different than what I’m doing here. Here, I’m starting with a stop loss, and then attaching different entry features to come up with the best complete trades.

So, previously I was looking at what was happening after the stop loss was hit (does the market continue against you, etc.) In this analysis, I’m looking at how much each trade made, in total.

To normalize returns, I divided each trade outcome by the number of bars the trade lasted in the market. This gives us the ‘returns per bar.’ Plotting this feature across every long trade looks like this when spread out by symbol:

The mean is slightly positive, which makes sense as most of these assets are directional (SPY, AAPL, QQQ, XLF). But, there aren’t any ‘clear winners.’

Here’s the same plot, on shorts only:

And somewhat unsurprisingly again, there is a slight negative mean. But, there is a much more skewed distribution towards the negative end which indicates that maybe our stop losses are not that good at shorts overall.

Looking at Longs

Let’s focus on longs for now. There are 59 stop losses, so I created a heat map of each stop loss and their average returns per bar.

Now we can see real differences in the data!

Here is a plot of the top 10 stop types by mean return per bar on a stacked histogram like the one we did with symbols looks like this.

Top 10 Stop Types by Return per Bar

Not really that interesting at all and really just reminiscent of the first plot.

The bottom stop types however shows a much more interesting story. There is an obvious negative skew, almost exclusively. So we now know that the type of stop does have an effect on expected returns.

Bottom 10 Stop Types by Return per Bar

Monte Carlo on Stops

So what if we just randomly select 5000 trades from each stop type and then plot those compounded returns? Below is just that with logarithmically scaled equity curves for the top and bottom 10 stops.

Our top stops are profitable, unsurprisingly. Our bottom stops are pitifully bad. But now we see that there is some alpha in the stop type regardless of entry and that we can filter these out easily.

Read more

My last post told you how to churn through 100 academic papers per hour with deep learning and LLMs. But just because you got an LLM to summarize 100 papers doesn’t really mean much unless you know what to do with it.

You could have the LLM just attempt to replicate the papers. But, you often will find that the results are unachievable (p-hacking), overstated, or slapped together to just sound good (LLM abuse in research on the rise).

It’s better to learn how to abstract the concepts you learn in the papers into a master understanding that then guides you towards a fountain of strategies that are more novel and better than what you can read about online.

And no, you do not need to take advanced mathematics. Instead, you can practice this process on pretty much anything and let the patterns emerge which give rise to novelty without you getting in the way.

Here’s the thing:

What is Abstraction?

In software engineering, the concept of abstraction refers to organizing similar pieces of code together and writing them under a single, unified piece of code that is then extendable and often times more closer to the ‘truth’ than a handful of different bespoke implementations.

Consider this:

What do a car, bike, and skateboard all have in common?

Of course, they are all vehicles. They all get you from point A to point B. But, most simply, they all have wheels. Thus, if we are describing this set of objects, we would call them ‘wheeled things.’ If we consider that they also carry a person from point A to B, we would call them ‘wheeled vehicles.’

These ‘wheeled vehicles’ are different than planes, helicopters, and boats which take you from point A to point B as well, but in a manner that does not consider wheels.

It’s important to note that we also could cut this along different lines. What if we partitioned the objects by ‘motored vehicle’ or ‘human powered vehicle?’ Well, then a skateboard would be in the same group as those swan paddleboats you always see in rom-coms.

This is the core philosophical challenge of abstraction.

But what is not a core philosophical challenge is abstracting from the bottom up.

Let the Cards Fall. Then See the Patterns.

Often times, we as smart people try to find patterns before the patterns emerge as a way to outsmart reality and prove that we are indeed very smart. However, premature optimization is the root of all evil. I know this, you know this (even if you don’t want to admit it), we all know this. Yet, we still can’t help ourselves from overcomplicating even the simplest tasks.

That being said, it’s very important to let the cards fall as they may and then see how you can group certain things together.

A great example of this is with the asset allocation papers I reviewed in the last post. I read a few of them that were so strikingly similar, that it informed me to create a hypothesis.

For example, Wouter J. Keller and Hugo S. van Putten from Flex Capital have published several asset allocation systems with similar names and unsurprisingly similar fundamentals:

• Protective Asset Allocation (PAA); A Simple Momentum-based Alternative for Term Deposits

• Generalized Momentum and Flexible Asset Allocation (FAA)

• Breadth Momentum and the Canary Universe: Defensive Asset Allocation (DAA)

• Growth-Trend Timing and 60-40 Variations: Lethargic Asset Allocation (LAA)

A Real Applied Example:

So let’s see how letting the cards fall plays out for the first step of each strategy:

Step 1 for Each Strategy:

• PAA: Define a risky basket of growth assets including Equities, REITs, Commodities, Gold, High Yield Bonds, Corporate Bonds, and Long Term Treasuries. Define a safe asset (IEF, or SHY & BIL).

• FAA: Define 7 mutual funds: VTSMX, FDIVX, VEIEX (equities), VFISX, VBMFX (bonds), VGSIX (REITs), QRAAX (commodities).

• DAA: Define a risky universe of growth/risky assets (e.g., global equities, commodities, REITs). Define a safe universe of low volatility assets like SHY, IEF, LQD.

• LAA: Define a risky universe of QQQ, IWD, GLD, and IEF. Define a cash universe of SHY, IWD, GLD, IEF.

Immediately, each strategy defines a risky strategy and a non-risky strategy.

Read more

As much as LLMs and AI seem to be writing our code, creating our art, and potentially replacing (or at least supplementing) our own artistic souls, they also still excel at pretty mundane tasks. When applied correctly, they can chew through hundreds of research papers at a time and give you deeper insights, inspiration, and clarity that you can use to apply to your own research process.

So, if you’re still reading papers off of Arxiv with your own human eyes (yuck!), you’re probably wasting a ton of your time that could be used in better and more productive ways.

Here’s the thing:

The Paradox of Infinite Potential

Here we sit in 2025 with chart after chart and story after story telling us how in 2 years we will have AGI. At the same time, every research article ever published by man is available at our finger tips, and any individual fact or piece of knowledge is accessible within 30 seconds from a computer in our pockets.

And thus, we become paralyzed.

Where do we start? How do we even begin to dig into this pile of research papers?

And once we chew through one and we think we have the answer, 12 more questions are raised and 20 more potential tweaks, remixes, and innovations on top of your original idea come into mind. Thus, the cycle repeats recursively and our head explodes.

The horror!

Don’t Be A Bricklayer

But, as our access to data speeds up, and our use to automated intelligence becomes more ubiquitous, we have to realize that we must think higher.

Just like a bricklayer eventually sees how they can build a building and must become a foreman to manage their own team to accomplish their greater goals. We must ourselves shed what we think is human based processing and pass it down to artificial intelligence so that we can step up to a higher level of reasoning and processing.

This concept is called cognitive offloading and it’s the same thing that happens when we pull out the phone’s calculator to get an answer to 12 x 25, even though we could probably do it ourselves.

This is directly applicable to trading strategy research and design, especially in the case of sifting through research papers. We really don’t need to scour every single paper to read every single detail when we can offload that functionality off to AI.

Instead, we can use AI to summarize batches of papers like so:

So let’s start with OCR - what it is, and how it turns PDFs into high quality Markdown files.

From Human-Legible to Machine-Legible

Research papers are usually in PDF format and often times have fancy tables and LaTeX math formulas. A lot of times they also come with charts and plots and things of that nature.

This type of rich media cannot be put into an LLM which is expecting text. Sure, some LLMs allow you to upload pictures so you can do analyses on them. But, their understanding of technical charts and data this way is often limited.

Instead, it’s better to use OCR (optical character recognition) to transform a rich media file like a PDF into text that is readable by an LLM and very cheap to compute.

I downloaded and tried out 9 different open-source OCR libraries:

• EasyOCR

• Tesseract

• PDFMiner

• PDFPlumber

• PyMuPDF

• PyPDF2

• Tika

• Unstructured

• Marker

And put them to the test against the OLMAR paper (here). Frankly, none of them did well at all except Marker, which is a self-hosted CNN model that runs on your own hardware or in the cloud. I was able to extract the PDF in about 90 - 120 seconds with my Apple M2 Max neural processor and it gave amazing results.

Here are some comparisons of the original PDF to the Markdown with LaTeX output on an online viewer:

Subscribe now

What you are seeing is simply amazing! And, this is in pure Markdown. So, while the math equations look all pretty in our viewer, they are just text and easily put into our LLMs.

Playing Senior to Your Digital Junior

Now with our initial proof of concept, it’s time to try this on a batch of papers and feed it into the LLM. You need to treat your LLM assistant as just that… an assistant. Don’t give it too much credit or room to make mistakes. Don’t let it stray from your guidance. It’s best if you have an idea and direction of your own that you leave somewhat hidden from the AI so that it doesn’t go on a tangent because they often think they know better than you.

My Process

I have been researching asset allocation and realized that most of them follow very similar rules. So, I want to get a batch of 25 papers, feed them into the OCR, and then ask an LLM to give me a report on the similarities of all of these papers.

Then, I should be able to understand at a higher level what asset allocation papers do. And, more importantly, I should be able to get some inspiration for my own asset allocation strategies based on what works.

And so, in went my 25 PDFs, and out came 25 Markdown files.

I compiled everything into one large concatenated text file that I could easily copy and paste into some LLM like so:

Now it’s as simple as plopping this into an LLM with a large context window (I use Gemini 2.5 Pro for this), and asking it some pertinent questions.

Subscribe now

Gemini is able to crunch through all of the context and give me structured output in a way that makes sense to what I’m trying to do.

I instantly gained the following insights:

1. There are ‘basic’ asset allocation systems and ‘complex’ ones that use machine learning, reinforcement learning, etc. that I probably am not interested in.

2. Most of the basic systems share a lot of similarities. They all trade basic baskets of ETFs. They all have some sort of ‘risk-off’ portfolio that is made up of treasuries, bonds, and other low risk, yield bearing assets.

3. I can begin to abstract these papers into a higher level framework such that I can generate my own asset allocation systems (can you see where this is going?)

Gemini also gave me a breakdown of all the papers together in this format:

• Module 1: Universe & Asset Definition

  • This module defines the "what" of the strategy.

• Module 2: Signal Generation Engine

  • This module is the "brain" of the strategy, deciding when to be aggressive or defensive.

• Module 3: Portfolio Construction Logic

  • This module translates the signals from Module 2 into precise portfolio weights.

• Module 4: Execution Protocol

  • This module defines the practical rules of implementation.

I then had Gemini give me all of the baskets that all of the strategies used, and continue with the signals and portfolio construction logic. I immediately started to see that Gemini was not completely correct, or not completely aligned with what I wanted and what I saw from my own expertise. I noticed that a lot of signals were acting as filters and we should split them apart.

This is where the cognitive offloading concept comes in. What I am doing here is having Gemini to the ‘low’ work of summarizing, finding patterns, and reporting to me. I then am retaining the ‘high’ work of analyzing, thinking about how I want to structure my problem, and using my own experience in systems design and engineering to have Gemini rework the concept at hand. They are the junior and I am the senior.

Next Steps

Now that I have a rough basis for what I want as a quant, I can start to think about building the system I want: an asset allocation system generator.

Because I had this in mind prior, I knew that I had to force Gemini to structure it’s responses in a certain way. I also never give the full responsibility to Gemini because I play the senior and they play the junior. It is important to always retain this separation because it is very easy for an LLM to run away with the task in a direction you don’t want at all, much like an enthusiastic new hire who doesn’t get the full picture yet.

User: “Can you just say how to solve this problem?”
AI: <Produces whole new code base of 10000 lines.>

From here, I will continue my research and develop into abstracting asset allocation strategies into a framework that will allow us to evolve our own programmatically.

Stay tuned for the next articles as I go through, step-by-step, exactly how I did it and how you can too.

Download the Tool

I’m including my easy PDF extractor CLI tool that I wrote alongside this blog post. Download it from the Google Drive, open up a terminal, navigate to inside of the folder, and then run python -m pip install -e . to install it (replace python with python3, etc. if that is your main python executable).

Download the Tool Here

Then, you can simply run the PDF extractor tool like so:

# Basic PDF extraction
pdf-extract input.pdf output.md

# With custom device
pdf-extract input.pdf output.md --device cuda

# With verbose output
pdf-extract input.pdf output.md --verbose

Or, embed it into your own Python project:

from pdf_extractor import MarkerExtractor

# Create extractor
extractor = MarkerExtractor(device="auto", verbose=True)

# Extract text from PDF
text = extractor.extract_file("my_document.pdf")
print(text)

# Extract and save as markdown in one step
text = extractor.extract_file("my_document.pdf", save_file="output.md")

Don’t forget to subscribe!

If you are already a paid subscriber, thanks so much for your monetary support.

And to all of my readers and subscribers, thank you for reading my post, and happy researching!

His breakthrough method hit the shelves in 2014. But, he has also authored many alternatives and updates to this type of asset allocation based on momentum.

I took one of his papers: Absolute Momentum: A Simple Rule-Based Strategy and Universal Trend-Following Overlay (SSRN Link here), reimplemented the algorithm in my portwine backtesting system (repo here), and found out that not only is the original paper still valid in today’s market, but a view simple modern day twists can exponentially improve the performance.

Demystifying Momentum Asset Allocation

Momentum based asset allocation systems are some of the simplest trading systems in the industry. They pretty much look at if an asset has momentum, and if so, allocates into it. There are other flavors in which out of a basket of 20 assets, you select the 3 with the most momentum or whatever. But, the rule set is pretty much always the same.

For the Absolute Momentum system, the rules are as follows:

1. For each asset, calculate the returns for the last 12 months.

2. For assets that return more than treasury bills over the last 12 months, invest in them.

3. For the others, rotate into treasury bills.

4. Every month, return to step 1 and repeat.

Ridiculously simple. And, Antonacci has the data to prove it.

But do these simple rules still apply today?

Replicating the Findings

I used my portwine backtesting system to create this simple strategy and run some simulations. However, from data back to 2000, and using the SHV ETF instead of investing in treasuries when out of the market, the news is not too amazing for Gary.

Absolute Momentum with SPY

Absolute Momentum with GLD

Absolute Momentum with URTH (MSCI ETF)

Gary’s system works well, especially with gold and assets where we sat out of the market in the 70s and 80s because treasuries were paying so much during those periods. When we start in 2000, when rates are low, sitting out of the market doesn’t really give us anything.

Even with the increased rates post COVID, we are not able to recover better performance than our MSCI analogue (URTH).

And Baskets?

But, what about a basket?

I tweaked the system to work with multiple assets such that we rebalance proportionally. If we hold 1 stock out of 10 in a basket, that 1 stock allocated 100% of the portfolio. If we hold 3 stocks out of the 10, each stock is allocated 33.3% of the portfolio. Etc.

I reused my Broad ETF basket from my first post:

broad_etfs = ["SPY", "QQQ", "IWM", "EFA", "EEM"] # No TLT or SHV
risk_free = "SHV" # TLT is another risk-free asset, won't include

Absolute Momentum with Broad ETF Basket

We cut off our drawdowns fantastically while outperforming an equally weighted. But, funny enough, post 2014 when most of his research is published, the system starts to decay against an equally weighted portfolio. Thus, while there is some validity to this strategy, I had to add some modern day tweaks to reignite the magic.

So, let us begin…

Innovation 1: Better Weight Allocation Methods

The original allocation method is binary: “Invest in the asset if the momentum is above 0, otherwise invest it in treasuries.”

This makes little sense once our basket sizes become huge. Out of 500 stocks, the variance in how much momentum surely has an effect on their forward returns.

I wanted to experiment with tweaking how much investment we put into each asset based on momentum, such as taking the top 5 ranked by momentum, scaling the weights proportionally based on how much momentum each asset has, etc. etc.

<PIC?>

Thus, I came up with several allocation methods to experiment with:

• equal: Equal weight among selected assets

• winner_take_all: All weight to highest momentum asset

• topk_equal: Equal weight among top k assets

• topk_proportional: Proportional weight among top k assets

• softmax: Temperature-scaled softmax weights

• power: Power-law scaling of weights

• threshold: Equal weight above quantile threshold

• rank_linear: Linear rank-based weights

• rank_exp: Exponential rank-based weights

• sigmoid: Sigmoid transformation of z-scores

• vol_adjusted: Volatility-adjusted weights

Applying the strategies to the original strategy and the NASDAQ 100

I applied the original strategy to the current NASDAQ 100 stocks and got this:

It’s nice. Edges out a little more than an equal weighted strategy. But here’s how it looks when we apply each strategy with reasonable default parameters.

Right away, we see some of these strategies being clear ‘winners.’ The topk strategies really boost performance (at the expense of risk) and the vol_adjusted strategy avoids the recent Fed unwinding amazingly.

I’m particularly interested in topk_proportional which concentrates winners, yet adds a bit of diversification, limited with a proportional weighting feature which makes sure our diversification is based on which assets contribute the most momentum to the portfolio.

I then did a parameter sweep to see if changing the top k number made a difference:

And our sweet spot seems to be between 7 and 10 assets, or the top 10% of the NASDAQ 100 at any point in time.

Innovation 2: Basket Selection With Genetic Algorithms

Next, I experimented with basket selection (which I have touched on in previous articles). Rather than using the hillclimbing algorithm that I used in the past, I used a genetic algorithm which just means I used the concepts of evolution to breed and mutate potential basket contenders until I found the best one.

Below is a cute video demonstration of genetic algorithms applied to solving the first level in Super Mario using neural networks. It’s worth a watch!

My system optimized for the Surefire Ratio, my own personal financial ratio which is far better than optimizing for Sharpe or total returns (you can read about here so you can implement it yourself).

Thus, I let the thing run for 200 generations and with 100 baskets in the population. I coded early stopping for when the validation set stopped improving along with the train set, with a patience of 25 generations.

For the allocation strategy, I used the topk_proportional with k set to 5. The basket was a selection of 50 stocks from the current SP500 components. The lookback time was kept at 12 months, but this can be experimented with.

The train period was set from 2000 → 2015. The validation set was from 2015 → 2020. The test was set from 2020 → now. Here are the metrics.

We see a clear evolution of success, although our population starts to ‘overfit’ to the train data after about 18 generations only.

The final basket from this run is the following, discovered at generation 15:

CMG, NFLX, WMB, TDG, UNH, CTSH, MSI, VST, TPR, BA, SW, NXPI, VTR, CHTR, LOW, VRSN, BWA, IR, V, VZ, AXP, GE, LHX, FANG, UBER, ACGL, TT, DLR, ON, AMP, CAG, NTAP, INVH, GOOGL, DPZ, DG, LMT, VICI, HBAN, COP, PODD, KIM, NVDA, SNPS, SPGI, CDNS, IEX, AZO, PARA, CBRE

The Findings

Thus, with these key innovations, I was able to take a classic system that was showing wear and tear and revitalize it into something much more modern and versatile.

Strategy Performance

=== Strategy Summary ===
TotalReturn: 38638.47%
CAGR: 26.97%
AnnualVol: 22.98%
Sharpe: 1.17
MaxDrawdown: -54.32%

=== Benchmark Summary ===
TotalReturn: 4501.75%
CAGR: 16.58%
AnnualVol: 18.28%
Sharpe: 0.91
MaxDrawdown: -52.09%

=== Strategy vs. Benchmark (Percentage Difference) ===
TotalReturn: 758.30%
CAGR: 62.65%
AnnualVol: 25.71%
Sharpe: 29.38%
MaxDrawdown: -4.29%

Transaction Cost Analysis

Due to the extremely low turn over (portfolio switches only once a month), the robustness is extreme. There is virtually no decay in the metrics even at 50 basis points.

Edge Decay Analysis

While the velocity of the edge seems to be decaying over time (2000 - 2008 had huge peaks of outperformance), the strategy still outperforms an equal weighted strategy.

Thus, we can carefully assume that our strategy still has some edge, although that edge is not as high as it used to be.

Overfit Analysis

There is risk of overfit. This is probably due to the fact that our edge in the 2000s was higher than it is now. This is to be considered when taking this strategy live.

Doing it Yourself

Want to add these innovations to your own strategy development pipeline? Want to explore some more of Antonacci's systems and boost their performance?

You can download all the code to recreate these findings including the vectorized strategy and genetic algorithm optimizer which you can use with any of your strategies here!

View Notebook Now!

Thanks so much and don’t forget to subscribe!

If you want more of Antonacci's works, some are freely available on SSRN:

Optimal Momentum: A Global Cross Asset Approach

Risk Premia Harvesting Through Dual Momentum

A Century of Profitable Industry Trends

Thank you all for your support, and happy researching!

In 2018, researchers Stěpán Balcar and Martin Pilát from Charles University in the Czech Republic published a revolutionary paper that combined the concepts of ensemble systems, evolutionary algorithms, and competition to create a highly adaptive trading system that claimed to greatly outperform the market.

Now, you would assume that such a sophisticated algorithm would require a large universe of stocks and careful, and often, rebalancing.

However, their system was able to achieve 71% annual returns since 2012 on only 20 stocks and rebalancing only once a month.

So how did they do it?

Well, although sophisticated, the system is highly effective. It uses a concept called Heterogeneous Islands to independently optimize 7 algorithms and have those compete at each rebalancing time (1 month).

Each island has its own optimizer and the islands do not communicate with each other. At each rebalancing phase, the algorithm sees which islands did the best, and gives the top more resources to then explore more between rebalance times.

Think of it as an immigration problem- islands that have more opportunity attract more workers, and thus can explore more potential solutions.

Want to Jump to the Strategy Code and Skip the “Blah Blah Blah”?

View the Code Now!

There are 7 islands that are used in the paper: Random Search, Hill Climb, Tabu Search, Simulated Annealing, Evolutionary Algorithm, Differential Evolution, Brute Force.

Each of these metaheuristics have their own situations where they work best, but that is often changing and dynamic based on the problem and the state of the system they are optimizing. And thus, this island system does a very good at managing resources between each system.

And so, I implemented the system in Python, using my portwine backtesting program (check it out here). Because the system is very computationally intensive, I used Numba to speed everything up.

A 20 stock basket made up of: AAPL, MSFT, AMZN, GOOGL, META, NVDA, TSLA, JPM, V, UNH, HD, PG, KO, MA, LLY, XOM, CVX, MRK, PEP, & WMT took about 2 minutes on an Apple M2 Max Macbook Pro with 12 cores.

The Equity Curve and Drawdown (good)

=== Strategy Summary ===
TotalReturn: 89882.96%
CAGR: 71.58%
AnnualVol: 40.55%
Sharpe: 1.77
MaxDrawdown: -59.27%

=== Benchmark Summary ===
TotalReturn: 1565.84%
CAGR: 25.01%
AnnualVol: 17.15%
Sharpe: 1.46
MaxDrawdown: -31.81%

=== Strategy vs. Benchmark (Percentage Difference) ===
TotalReturn: 5640.25%
CAGR: 186.16%
AnnualVol: 136.51%
Sharpe: 21.00%
MaxDrawdown: -86.34%

The system smashes the performance of an equal weighted strategy, which tells us that it is not just the fact that these are blue chips that make them good.

The drawdown is about twice the benchmark, but returns more than double the CAGR, and so it’s better on a risk basis.

The Edge Decay (none)

There is no edge decay. In fact, the edge is marginally improving over time, albeit at a snails pace. This tells us that this strategy is not using factors of yesterday’s market and can be used today to make investment decisions (at your own discretion).

The Transaction Fees (few)

Also, because we only rebalance once a month, the performance you are seeing is accurate. Even at 50 basis points, we still get 62% CAGR and a sharpe that is better than buy and hold.

Next Steps

Ready to play with the code and test out your own configurations or even deploy it live? Go ahead and click on the button below to get the notebook:

Go to the Notebook

Don’t forget to subscribe as well!

Subscribe now

Your support is everything to me, paid or free. And so, thank you so much for being with me in my journey! Happy researching!

Quantitative research is marred by directories of data, long-winded mathematical models, and Jupyter Notebooks that plot out charts of raw statistical distributions.

However, people are visual creatures. Our research process can be made a whole lot better through creative UI design and more humanistic factors.

Using better tools and systems that account for our visual nature improves our research process drastically, and above the processes of our mathematical peers.

Here’s what I did:

Using React, a simple component library, and Cursor, I was able to build a super fun, interactive site that lets you explore 50 different moving averages and how ‘good’ they are when applied to a strategy.

Want to just check out the app? Click on the button below and play with it now!

Moving Average Zoo

Let’s get started!

Dealing With the Status Quo

Most research begins with an idea: ‘what if?’ We then go through the scientific method to prove this hypothesis.

• “If I enter a trade when the RSI is at 30, do I generally make money?”

• “If I rotate my capital into the top 3 stocks in this ETF baskets based on momentum, can I beat the market?”

• Etc.

However, these hypotheses are targeted. When we are proving or disproving something, we are extremely precise.

• “No. RSI entry based points are a bad indicator for my timeframe and assets that I trade.”

• “Yes. Using momentum to rank assets in a basket generally gives me more upside than the general market.”

Likewise, how we prove or disprove these theses come down to the nitty-gritty of data processing. It’s about the numbers.

Where Things Break Down

So, for targeted questions, this type of research is great. But what about the ideation phase? What do we do when we have no hypothesis?

We can do large parameter sweeps and amass massive amounts of data, CSVs, Matplotlib charts into folders and click one by one until we find a configuration that looks interesting. But, this is not it. Something is missing.

User experience design (UX) has a concept of Browsing versus Searching when it comes to interface design.

Imagine an online store. If you know what you want, you just need to type it into the search box and boom. It’s there on your screen.

But what about when you don’t know what you want? Well, that’s when you browse. Having the ability to look at all the content and select what you want when you are pulled into it is key in any shopping experience (or online blog, streaming service, social media platform, etc.)

Browsing With Data

So, taking this concept and applying it here, we search when we know what we are looking for. We search when we have a question that needs to be answered. We refine and compare our search with our data and using the scientific method.

We don’t have our browse path established. Let’s do that now.

I have 50 moving averages that I want to compare. I want to see which ones are the best. How well to each track the price of the asset? How well do they smooth out the signal? Are there outliers?

All of these factors I can extremely quickly glean from a chart.

How can I answer all of those questions with data? How do I define ‘the best?’ How do I define ‘smooth?’ What if my definitions of those things change over time? Today I want something that is more smooth over accurate. Maybe tomorrow that changes.

I don’t want to have to redefine my humanistic requirements for a computer to only then have to translate what the computer spits out back into my humanistic requirements.

Building the Zoo

My solution was to build an interactive application that let me visually play with 50 different moving average indicators, their parameters, and test on mock strategies which ones are ‘the best.’

My task list:

1. UI

   1. Dropdown selection of the moving averages

   2. Dynamic loading of parameter inputs for each indicator

   3. Bar chart with indicator painted on

   4. Strategy section for testing how ‘well’ a certain indicator did

2. Other bits

   1. Implement 50 moving averages in Javascript

   2. Design different strategies to test the signals on

   3. Generate LaTeX definitions for all the indicators

I went with Cursor as my IDE, generating a new React project using Vite and Typescript. I also installed the MUI component library to make prototyping quicker.

The first step was to populate a dropdown with the 50 moving average indicators I wanted to implement:

I then also coded the Javascript implementations of all the indicators, which informed me on which parameters were modifiable. I created a JSON file for all of the indicators and their metadata like so:

Which then allowed me to create a dynamic component for parameter entry depending on which indicator was selected by the user:

After this, I dropped in TradingView’s Lightweight Charts library and loaded SPY data onto a bar chart. Given the implementations of all my indicators, and the ability to modify the parameters, I could quickly update the chart with the new indicators without much hassel.

Adding the Strategy Backtester

So, I had a working application that let me visually play around with a ton of moving averages. I was already finding a lot of really good indicators that looked good to me: resistant to outliers, nice smooth curves, etc.

However, I imagine that another trader would come along and get their own inspiration.

I had successfully built the browser.

But, this wasn’t telling me how ‘good’ a moving average was. So, I decided to add a strategy backtester with certain stock strategies that used the moving average. I came up with the following systems that use a single indicator:

• Slope Strategy

  • Long when the indicator slope is above X. Sell when the slope is negative.

• Price Crossover

  • Long when price crosses above the indicator. Sell when it crosses below.

• MA Band Strategy

  • Long when price is near the bottom of a band (calculated as X% width above and below the indicator). Sell when it is near the top of the band.

• Momentum Strategy

  • Long when positive momentum of the indicator is strongly positive. Sell when it weakens.

• Mean Reversion

  • Long when the price is X% deviations below the indicator. Sell when it returns to the indicator.

• Volatility Breakout

  • Long when the price breaks above the indicator in high volatility periods. Sell on reversals.

• Trend Following with Stop Loss

  • Long on an uptrend and attach a stop loss for sells.

Like the indicator parameters, I coded dynamic components for the entry of the strategy parameters. I also added an equity curve, tear sheet, and trade list for further analysis.

Deploying It

Because I’m using a super standard stack: React, Vite, and Typescript, I can use a cloud application platform like Render. My build command is just npm install; npm run build, so I hooked it up to my Github repo and deployed it without any issues.

The Results

In the end, the zoo was complete. If you want to play with it yourself, click here:

View the Zoo

You’ll be able to

Next Steps: A Full Sweep

Of course, this tool is fun. But it should be paired with some data analysis. The best setup is exploratory / browsing tools to find out the rough sets that work so you can use more rigid programming and analysis to figure out truly how to harness what you find.

You can also try building your own interactive applications. Maybe build one to highlight different regimes or to set buy and sell points to help you label your data for a machine learning pipeline?

Maybe a strategy blender tool that lets you upload your strategy returns as CSV files and use sliders to play with the ratios so you can come up with the best blend of each strategy based on what you want?

The world is wide and open. Have fun and experiment!

Code for the Moving Averages

The code for the moving averages is available in the Google Drive as a Python file. I will be experimenting with implementations in other languages soon so you can use these indicators in TradeStation, MultiCharts, TradingView, and MetaTrader.

I’ll also continue my research into moving averages and quantifying which ones are the best.

So, stay tuned, and thanks for the support!

Get the Code

Happy researching!

Stop losses are a way of life for a trader. They are often ‘do or die’ in situations of intraday and leverage trading. However, we think that the ‘gold standard’ is the average trailing stop. Maybe we add an ATR band to it if we are feeling fancy.

But the reality is that there are much more effective stop loss strategies that exist. And, these strategies are not part of the mainstream.

Here’s the thing:

I found a new class of strategies that are completely different than our current understanding and not only defend capital, but let winners ride better than the state of the art.

How much are you letting lose by using the current state-of-the-art? The answer is too much.

What’s in a Stop Loss

A stop loss is an order that we take out to close our current position when the price moves too much against us.

We can use them to minimize downside risk: “I only want to be down a maximum of 5% on this trade.”

Or to create risk-reward systems: “I will stop out trades that move 1% against me, and take profits from trades that move 2% with me.”

The challenge is selecting a stop loss that cuts your losses, but also lets winners ride.

Far too often does a stop loss actually turns a trade that would have been a winner into a loser. Like the example below:

So how do we balance between downside risk mitigation and upside potential? Well, there are some more dynamic trailing stop loss systems like ATR and Parabolic SAR that take into account volatility, trends, and momentum. They seem to help.

But the reality is that is all depends. There isn’t really a good metric to determine how well a stop loss is at risk mitigation and upside potential… until now.

Determining How Good A Stop Loss Is

Good is a loaded term.

We want to find the best stop loss. But what does that mean exactly? The ‘best’ in every single situation? How do you even measure the best?

To solve this, I came up with a simple system. I simulate taking out a trade every single day, a long and a short, and I ride that trade until it is stopped out.

This generalizes the stop loss over every potential trading strategy.

I then look at the next several time horizons forward: 1 day, 7 days, 14 days, 30 days, 90 days, etc. to see how much downside I avoided. I also record how much upside I achieved on each trade.

Thus, I can quickly see if a stop loss is ‘good’ or not based on two basic metrics: average amount of downside it avoided versus the baseline, and how much average upside it achieved by letting winners run.

What this Looks Like in Practice

I wrote an ATR Volatility Stop Loss and set the window to 14 days and the multiplier to 2x.

This is a non-trailing stop that sets a fixed stop lot price determined by the ATR calculation on entry.

When I run this on NFLX, I get the following output.

The violin plot shows the distribution of returns after our exit. The x-axis is how many days forward. You can see that most time horizons have a mean return that is negative, meaning that our stop loss consistently prevented further downside risk.

The entry → exit plot tells a different story. All returns are negative, of course. This is because this is a non-trailing stop or a stop that never sets its stop level above the entry price. There are some stop losses where this will be positive.

The 1-Day Post-Exit Returns plot shows more closely the distribution of the first violin. We get an exact metric as to how well this system prevented further ruin, which we can consider it’s defensiveness.

With this system in place, we can expand this to:

1. More systems

2. More parameters

3. More stocks

And get an even better picture at generalizing how good a stop loss is.

The Initial Candidates

There’s a ton of literature on the ‘standard out-of-the-box’ stop losses. If you are familiar with MetaTrader and Forex trading, you probably have installed a thousand different EAs with wild and zany stops that ultimately did nothing to help your slow (or fast) grind to an account with $0 in it.

So I wanted to start with these as a base, but also generate a list of novel and new stops that could lead us towards a new direction or discovery in the stop loss space.

I started with the following:

1. Fixed loss ← our baseline or ‘control.’ It always loses money, because it’s only hit when the trade is underwater. But, it could save us from future losses.

   1. Never readjusts

   2. Parameter sweep: 0.25%, 0.5%, 1%, 2%, 5%, 10%, 20%

2. Trailing Percentage Stop:

   1. Readjusts stop X% below the last close.

   2. Parameter sweep: 0.25%, 0.5%, 1%, 2%, 5%, 10%, 20%

3. ATR Trailing Stop

   1. Readjusts stop based on ATR volatility across a window

   2. Parameter sweep:

      1. Window: 7, 14, 28, 60, 90, 180

      2. Multiplier: 1, 1.5, 2, 3, 5

4. Parabolic SAR Trailing Stop

   1. Readjusts stop based on acceleration

   2. Parameter sweep:

      1. Acceleration: 0.01, 0.02, 0.03, 0.04, 0.05, 0.07, 0.1

      2. Max Acceleration: 0.1, 0.15, 0.2, 0.25, 0.3, 0.4, 0.5

I ran every single parameter combination on 8 stocks, SPY, GLD, JNK, AAPL, QQQ, TLT, USO, and XLF, to get a wide array of situations that I could then use to generalize how good a stop loss strategy really is.

The Findings

Let’s dive into what I found:

Fixed Stop Loss:

Unsurprisingly, the Fixed Loss cuts our losses, but really does nothing in relation to saving us from further declines. There is a slight pattern that shows that tighter stops prevent us from losing a whopping 6 basis points more, but that really is not enough to build a system around.

Trailing Percentage Stop Loss:

This stop loss is a bit better. The average returns that one gets when using this stop loss is actually positive, which makes sense because the stop price adjusts as the trade moves in our favor. However, a tighter stop is better (0.25%, which is not a lot at all). And, it doesn’t really seem to help us prevent future downside, as the next days returns are only 15 basis points against us on average.

Trailing ATR Stop Loss:

In an unexpected turn of events, adding an ATR actually hurts our general performance, especially when using a multiplier of 1. It seems that multipliers of 1 are making our graph seem worse than it might be, as they are clear outliers.

But, regardless, what this shows is that ironically, setting the multiplier to 1 stops us out the day before on average we would make 0.6% or 60 basis points. That’s a lot!

Other configurations seem to do better, with their averages being slightly negative.

Trailing Parabolic SAR Stop Loss:

While hard to read, this one is so far our ‘state-of-the-art.’ Most time horizons forward, every stock, and every parameter selection all closes negative on average. This means that in most cases, the Parabolic SAR will protect us from further losses. In fact, you can expect 30 basis points of immediate next day savings.

Going Nuclear - The Other 83 Stop Losses

But what fun is 4 when we can create and test so many more? I created 83 more systems that expanded across a super wide array of domains.

These systems are classified into the following types:

• Trend indicators (ADX, ATR, Moving Averages, Supertrend)

• Oscillators (RSI, MACD, Stochastic, Williams %R)

• Volatility measures (Bollinger Bands, Keltner Channels, Standard Deviation)

• Volume-based (OBV, Money Flow Index, Volume Spike)

• Pattern recognition (Doji, Bearish Engulfing, Three Bar Reversal)

• Support/Resistance (Pivot Points, Fibonacci, Support/Resistance levels)

• Time-based (Day of Week, Seasonal, Time-based)

• Advanced (Point & Figure, Renko, Triple Barrier)

And from these systems, emerged a few winners. Every one of these is a completely new class that outperforms Parabolic SAR. Let’s get into it.

#1 Pivot Point Stop Loss

The Pivot Point Stop Loss uses the classic pivot point formula to determine where the stop out show be placed. This, however, cannot guarantee to be trailing. So, it beats Parabolic SAR by 176% in terms of risk mitigation. But, it does not trail as well.

On average, 83 basis points are avoided per trade when using this stop loss.

#2 Moving Average Crossover Stop Loss

As you can imagine, this stop loss is activated when the price crosses over or under a given moving average based on which direction the trade is headed (crosses under for longs, and over for shorts).

While it seems simple, it actually outperforms the more complex Parabolic SAR in both general profit capture and risk mitigation.

On average, 130 basis points are captured on the upside and 79 basis points are avoided on the downside.

#3 Keltner Channel Stop Loss

Similar to the prior stop loss and the Parabolic SAR, but it uses Keltner Channels instead as trailing bands. So far, this is our best trailing system, as it on average captures 211 basis points per trade, and mitigates 59 basis points on the downside.

#4 Maximum Drawdown Stop Loss

The Maximum Drawdown Stop Loss is closely related to a standard trailing stop loss. It looks at the peak achieved and

#5 Historical Quantile Stop Loss

The Historical Quantile Stop Loss looks at recent history and determines if the returns can be binned within one of the lowest quantiles. If so, the trade is exited. This system captures 375 basis points of upside on average and avoids 113 basis points of downside.

An incredible system that shows extreme versatility for every situation.

#6 - #10: It Gets Even Better…

As a special treat to my paid subscribers, I am giving 5 extra systems that perform even better. Just scroll to the bottom of the post to see the charts and pop open the Google Drive to get the code.

Want a sneak peak? Sure thing.

• #6: 334 basis points upside gained, 223 basis points downside avoided

  

• #7: 528 basis points upside gained, 97 basis points downside avoided

  

• #8: 390 basis points upside gained, 190 basis points downside avoided

  

• #9: 402 basis points upside gained, 185 basis points downside avoided

  

• #10: 334 basis points upside gained, 223 basis points downside avoided

Applying These To Your Trading

And now, with 10 new completely unique classes of stop losses that deviate from the usual trailing, ATR, and Parabolic SAR (and perform way better than all of them too!), you can go and apply them to your systems today.

Why let your good trades suffer from using poor and outdated systems? Use something new, modern, and most importantly, better.

You can get the code for all of these systems in here:

View the Notebook

Finally, this project dumped out about 11GB of files. All of it is available to my Founding Members. Paid members of course get the 10 systems outlined in this post in complete Python code. But for those specialists that want to dig even deeper into what I did, the raw code, image, and data dump is available to those in the Founder Member subscription.

I want to thank all of my subscribers, paid or free, for supporting me and my work. I never thought I would be able to write about what I love most and gain such a great following.

If you have any ideas you want to see me touch on, join the chat and start a thread! I’ll respond to everyone personally.

Thanks again everyone, and happy researching!

It’s dated technology. The radio. But underpinning its humble origins is an electrical engineering field known as signal processing that has applications in literally everything around us: WiFi routers, making music sound better, and even detecting earthquakes.

While many readers may assume that I built my system with bespoke approaches tuned specifically for financial applications, the reality is that I am using the same basic algorithms that a regular radio still uses today.

The assumption of specialization and complexity leading to better results is an attractive folly. But, the opposite is more often true. If we are unable to control our biases as traders, we will never break away from the same cycles that keep us glued to our screens losing money.

Here’s the thing:

Not everything needs to be complex and overthought. Tried and true methods that make sense given the application will always outperform the state-of-the-art used in the wrong way.

I’m here to show you how, by following the lessons of my trusty old FM radio.

Turn on the Radio

Imagine you’re a radio station operator in the 1940’s. Your job is to transmit only the finest news in the nation. You walk in with your three piece tweed suit on and flip on the power switch.

You grin looking out the window as the radio waves permeate across the great nation, with a glass of cold milk in your hand.

If you had the eyes of a mosquito (which actually sees infrared and not radio waves, but I digress), you may see these squiggly lines dashing across the room:

It looks complex at first. But, at second glance, you can clearly see that is made up of cyclical patterns. The first one is a very long cycle going up and down, like this:

But there also seems to be a second component and trend in this wave that is a higher frequency. I added that shorter frequency to the smoothed trend line below:

We are starting to break this wave into its components or trends. This breakdown illuminates to us the cyclical trends and patterns that exist in an otherwise complex wave function.

In fact, all waves can be broken down into a sum of smaller sine waves. This is also known as Fourier’s Theorem and has huge implications in terms of signal processing, mathematics, etc.

Filtering out Frequencies

The way that this is applied to the radio is when you tune to a station. Each station has the main wavelength that it is being broadcasted on (90.1 MHz or 90.1 million oscillations per second). And on top of that wave, the actual sound is being encoded.

So your radio uses what is called a bandpass filter to filter out that main wavelength. What remains is the signal that carries your music, or static in the case of there being nothing broadcasted on said frequency.

Applying to the Markets

And so, we can use this same underpinning technology to ‘tune’ to certain frequencies to identify trends in the market.

However, consider this:

There is clearly a seasonal trend in Wheat futures that fluctuates about once every 6 months. Identifying this trend, when it is happening, and the amount of ‘energy’ in said trend would yield us a very profitable system, especially if automated and applied to hundreds of assets at the same time, which is exactly what I did.

Crafting the Strategy

A bandpass filter is good at isolating specific frequencies, but also is used to isolate a range of frequencies. So I defined a range of cycles that I want to look out for in each asset I am trading.

I picked a low end of 0.01 hertz, or one cycle every 100 days, and a high end of 0.1 hertz, or one cycle of every 10 days. This gives the strategy the breadth to be able to identify trends from any range that is interesting to us while cutting out the noise of daily ‘trends’ that result in noise pollution or over trading.

Above is the result of the bandpass filter on the SPY. I shaded the price line green when the bandpass was increasing and red when it was decreasing. You can see how it is able to roughly identify trends.

Thinking in Energy

However, it’s not accurate enough to become a strategy. So on top of the bandpass filter, I added a Hilbert Transform which quantifies the amount of energy in a signal. This energy can be used, especially in a comparative situation, to find out which signals are the strongest, regardless of the direction they are heading.

The Hilbert Transform uses the bandpass filter components to determine where in the cycle we are and thus how energetic this cycle is.

Think of boat on the water. It bobs up and down with the waves with the waves being cyclical. Every minute the boat hits the peak or the trough in the wave. Because we know the wave is behaving regularly, we can measure the velocity of the boat being lifted on the wave to determine well before we hit the peak of the wave how strong the wave is.

The Hilbert Transform quantifies this as ‘energy’ or strength of the wave. See above. Using the varying amplitude, an instantaneous envelope is created that can tell us how strong the signal is along its regular path.

I applied the Hilbert Transform to the SPY with the bandpass filter and highlighted where the envelope is greater than 3x the rolling standard deviation across 60 days. Now, you can see clearly how high volatility moments in the SPY are identified.

Scaling Across Assets

With this concept in mind, I built a trading strategy that looks at all 500 components of the SP500. The rules are as follows:

1. Ingest prices and keep track of history.

   1. Every period, I track all of the assets I am trading and keep a history of their returns.

2. Calculate the Bandpass Filter

   1. Then, I calculate a Bandpass Filter for frequencies 0.01 and 0.1 for every asset to determine their core trend components.

3. Compute Instantaneous Energy via Hilbert Transform

   1. Next, I compute how much energy is in each asset with the Hilbert Transform as laid out above.

4. Measure Energy Momentum

   1. Rather than just selecting assets with high energy, I look at assets with the highest change in energy. This identifies the assets that are poised to pop.

5. Rank and Normalize into Weights

   1. I take the top 5 performers and assign weights to them exponentially based on their rank, giving the strategy a bit of diversification without missing out on the true winners.

6. Invest

   1. With the calculated weights, I now adjust my portfolio. I run this once a week on Mondays to keep transaction fees low.

The Results

The results of this strategy are shocking. $1 in 2000 turns into $6000 in 2024 (without fees.) The risk taken, however, is greater than an equally weighted portfolio of SP500 components. And so, this strategy is not without some downside.

Similarly, this strategy is more sensitive to transaction fees than other weekly rebalancing strategies.

A CAGR of over 41% drops to around 30% with only 10 basis points of fees, which is standard.

More research needs to be done in terms of figuring out how to reduce turnover. There is also much more to be done in terms of the underlying system- experimenting with bandpass frequency ranges, using explicit high and low pass filters, etc.

Downloading the Code

The code of this strategy and the accompanying visualizations is all available here:

View Notebook Here

Don’t forget to subscribe!

And as always, thank you for your support. Happy researching!

We’ve all used it. It’s seen as the ‘gold standard’ of investment metrics. But the Sharpe ratio is a dated formula that takes a naive assumption on the market and runs us into walls. It has no concept of prolonged drawdowns or causality, and those that continue to use it as the gospel are quantitative luddites handicapping their own success.

But get this:

With a simple financial ratio, we can describe what makes a strategy great and incorporates all the blindsides that the Sharpe ratio misses.

The Dull State of the Sharpe Ratio

All, and I mean all investment managers and hedge funds use the Sharpe ratio as a way to advertise performance. But the Sharpe ratio only looks at the mean returns versus the volatility of those returns. It has no concept of losing streaks, time underwater, and it penalizes upside volatility the same as downside volatility.

Even more “sophisticated” metrics like the Sortino and Calmar ratio, which consider things like downside volatility and maximum drawdown, do so in a way that treats returns as independent and identically distributed which is simply not true.

Equal Sharpes, Contrasting Curves

Consider the following two equity curves. They have the same Sharpe ratio. They end up on the same exact equity. They should be equal, right?

But which one would you rather invest in? It’s clear that the Baseline is better than the AR(1) Clustered strategy from a visual perspective. But our financial ratio is telling us that they should be the same.

The reason is because a Sharpe ratio treats every return as completely independent. It does not consider sequence, prior returns, etc. as at all important. When we look at the drawdown of both strategies, we see the clear issue.

While although both of them after 250 days end up on the same amount of equity, how they get there is extremely different.

No investor want to be in prolonged drawdown, even if that means lower returns. In this case, the Baseline strategy is not showing as much momentum. But, it’s, for the most of its run, outperforming the AR(1) Clustered strategy.

What is needed is a metric that considers this.

Step One: The Integrated Drawdown

Rather than just looking at the mean returns and their volatility, like the Sharpe ratio does, we need to look at the way that a strategy has actually played out over time.

This rejects the idea that returns are completely independent and identically distributed (idd). And, this makes sense. If you have a system that performs well in high momentum periods of the market, it’s going to win consistently and repeatedly during those periods.

Likewise, if the market is choppy, it’s going to struggle. These periods generally last for some time. It is not just that one day it exists, and one day it doesn’t. Otherwise, it would not be considered momentum.

And so, let’s instead take a strategy and add up all the area underneath the drawdown curve. This will be called the Integrated Drawdown. It tells us not only how much we’ve drawn down, like a maximum drawdown metric, but also for how long.

Strategies that drastically drip really quickly, but recover, are generally better to investors than strategies that moderately dip, but remain underwater for months or years.

Thus, we can define the Integrated Drawdown as:

Which for regular people, simply means, add up the area under the drawdown curve. Now, our plot looks a lot better:

The baseline strategy has an Integrated Drawdown of 7.05 and the AR(1) Clustered has an Integrated Drawdown of 21.27. Higher scores are worse. A ‘perfect strategy’ (which is not possible unless it’s 100% risk free) has a score of 0.

Step Two: The Integrated Upside

And so, on the flip side, we can also look at the Integrated Upside which I define as all of the area above the initial equity value of 0 for a given time frame. This, especially in comparative analysis, is helpful in showing which strategies are performing the best over time. Strategies that maintain their edge will be rewarded greatly with a higher Integrated Upside.

I define the Integrated Upside as follows, with a definition for the Cumulative Integrated Upside at any given step in the equity curve:

Here is how the Cumulative Integrated Upside evolves over time on our two equity curves:

You can clearly see how the Baseline strategy is superior because it maintains its equity above 0 for the entire series. And, while the two eventually end up on the same equity curve, that is not as important as being above water for the entire duration of the timeframe we’re looking at.

And so, although the Baseline does have period of drawdown where it suffers, it’s not doing so in any catastrophic way.

Furthermore, if the AR(1) Clustered strategy catches up quickly over time while the Baseline stagnates, we will be able to see this in the increased change in the cumulative integrated upside over time.

We can also use this metric in a windowed strategy to get a better picture of which strategies are performing well in a given moment in time.

Step Three: The Integrated Upside Downside Ratio

The Integrated Upside Downside Ratio is simply dividing the Integrated Upside by the Integrated Downside.

This gives us a metric that exponentially improves as the amount of time underwater shrinks while also rewarding increasing upside.

Remember, a large Integrated Drawdown is bad, while a large Integrated Upside is good. Below is the change in the IUDR if we keep the downside fixed and change the upside (top plot), and vice versa; keep the upside fixed and change the downside (bottom plot).

The metric rewards minimizing the drawdown vastly more than increasing the upside. This is good for optimization problems where you want to avoid time underwater first, and once a system has optimized to some local minima, you want to slowly investigate how to increase the upside.

Final Step: The Surefire Ratio

The Integrated Upside Drawdown Ratio is an amazing concept, but it still has it’s flaws. I can come up with two equity curves that have the same IUDR, but vastly different equity curves.

To fix this, I introduce the Surefire Ratio, which simply multiplies the IUDR with the final equity, thus scaling that ratio by which strategy performed better. Therefore, our final equation is:

And that chart now looks like this:

With the Surefire ratio of Strategy 2 being 57% greater than Strategy 1.

Next Steps & How to Get the Code

So, ready to start using the Surefire Ratio in your code? Visit the notebook now and get the Python definitions and start plugging away!

View Notebook

Don’t have access? Become a paid subscriber and gain access to this notebook and all other strategies and notebooks from previous posts and future posts!

Now that you understand the weaknesses of the Sharpe ratio and the benefits of more sophisticated metrics, why would you ever turn back?

Let me know how this has helped you in your search, and like always, happy researching!

As traders, we scour the internet, books, and articles for industry specific information to create our new fancy algorithms. The Black-Scholes model, Markowitz Mean-Variance portfolio optimization, the Capital Asset Pricing Model (CAPM)… These are all systems designed for investment purposes solely.

But what if solutions from a completely different domain, ones that seem completely detached and even too simplistic to make an impact on any investment decision, turn out to outperform many of these established models?

I discovered that the same system to maintain the temperature of your house is adaptable to markets, and not just by a small edge either. The data shows 24% CAGR on SP500 components, beating an equal weight strategy by 2x.

We’re often quick to dismiss out-of-the-box thinking or get stuck in the trap of ‘industry knowledge.’ But doing so ‘boxes’ us into rigid thinking patterns that every other trader uses, and thus provide no novelty and stale alphas that have been priced into the market for decades.

Here’s the thing:

Being open to concepts and ideas that are not part of the norm is often seen with ridicule and rejection. But, they are often the holy grail of alpha. Creativity, persistence, and ingenuity is what separates the good from the great.

And here’s how I did it.

Thinking in Thermostats

Behind every thermostat is a simple system. If the air is too hot, it turns on the air conditioning. If it is too cold, it turns on the heat. Of course, the A/C and heat take time to turn on and off. And so, often times the thermostat might ‘overshoot’ or ‘undershoot’ that comfy target of 21°C (72°F).

The class of systems that govern this behavior are known as Proportional-Integral-Derivative Controllers. These controllers take into account:

1. The current error of the system (Proportional)

   1. What temperature it is right now versus what temperature we want.

2. The accumulated error of the system over time (Integral)

   1. How long as the temperature been off target.

3. The rate of change of that error (Derivative)

   1. Are the settings of the system making things better or worse?

These factors are added together to create a total error which influences what the system should do next.

This feedback tells the controller whether to increase or decrease the heat, by how much, and how quickly.

Visualizing with Boats

The same problem exists in navigation. A boat’s rudders need to maintain a certain heading. But, ocean currents and winds push the boat off course and the rudders need to compensate.

To illustrate how PID controllers work, I made a visual example. Our boat’s target heading is set at 45 degrees and I added simulated currents to attempt to push the boat off target. Here’s the path of our ship.

You can clearly tell how there are periods where the boat is wavering from it’s target waypoint (45 degrees forward). But, over time, it nudges back over to the target and continues it’s path.

You can see the PID controller working under the hood here:

Let’s go through each graph together.

Ship Heading vs. Target

This plots the direction that the boat is heading over time. The sudden dips and spikes are the programmed currents knocking the boat off course. But each time, the PID controller adjusts the rudders to compensate such that the heading is realigned to the target, denoted by the green horizontal line.

PID Components Over Time

This plots the ‘under the hood’ components of the controller. You can see the proportional error which spikes immediately in the opposite direction of the heading. This is because if the boat is pushed to the right, we need to knock it to the left. Thus, the action is the opposite of the error that we need to take.

The integral error is the accumulated error over time. Or, how much are we off from our target in total? This tells the controller how to react after we immediately react to the sudden currents. After we adapt to that sudden change, are we still off course? How to we slowly turn the ship back on course over time?

The derivative error is the change in our error. You can see how it spikes with the proportional error, but very quickly levels back off to around zero. This is helpful for the system to react extremely quickly, or to understand in what way the error is being applied to the system (quickly or slowly).

Controller Outputs vs. Disturbance

This plots the actual ‘shocks’ or current disturbances and the end action that the rudder takes to adjust for these shocks. The rudder’s actions are clipped at 30 degrees either way, as is the case with real world rudders and prevents over compensation which would spin the boat totally out of control.

You can clearly see how the rudder quickly adapts to the shocks, and then slowly readjusts to 0 as it gets closer to the target heading, just like how a real boat’s navigation system would work.

Applying to the Markets

But sure, boats and theromstats are cool. But what does this have to do with markets? They are hardly the same thing. There is no fixed ‘target’ of where we are heading. Markets are chaotic and constantly dealing with shocks and unexpected behavior. The problems are completely different.

That might be so. But, the PID controller is actually a great adaptive system for the markets.

I made a simulation where the target of my controller was a Sortino ratio that was high enough to promote the controller to accumulate wealth without the error being absolutely insane where the controller doesn’t know what to do.

I also constructed three assets: Asset A, Asset B, and Cash. The system could allocate in any of these assets over time. The system only knows the three components (P, I and D) of how off it is from the target.

To illustrate this better, I added regimes to Assets A and Assets B and alternated between them:

1. Asset A outperforming Asset B

2. Asset A underperforming Asset B

3. Both Asset A and Asset B underperforming cash

This gives the controller different market conditions in which is has to adjust its weights to maximize wealth. Here’s what happened:

You can see the 20-day rolling Sortino ratio for each asset in the top chart which illustrates where the controller should be headed. And, unsurprisingly, the portfolio weights shift from Asset A to Asset B when the Sortino ratio of each asset adjusts.

You can see in the final plot how much better the PID controller performs that any of the assets, as it is tactically adjusting its weights based on how each asset is performing.

Above is a chart of the PID components and the rolling Sortino of the PID strategy itself. You can see that the proportional error adjusts often as the value of the portfolio changes over time. However, because the portfolio is often above the target Sortino ratio of 1, the integral error is constantly negative. This is good, as it means that the system, over the long term, is performing well. The derivative error is a bit harder to see, but you can see how it is quickly adjusting to the small daily movements of the portfolio.

Achieving 24% Returns on a Weekly Strategy

And so, I moved onto developing an actual strategy. This system was actually developed with the help of my automated research process, and so it’s great to see that such a powerful concept was able to come out from it.

That being said, I incorporated the concepts here into a single system that trades all of the SP500 components (as of today) on a weekly basis.

The target metric is a Sortino ratio, just like the version above. Except, instead of the controller adapting at every time step, it only does every 7 time steps to avoid excess turnover and keep transaction costs down.

Furthermore, every asset has it’s own controller assigned to it such that the strategy is an accumulation of all the controllers at once. This allows for a per asset granularity of control that would be very hard to achieve otherwise.

I used exponential ranking to then take the performance of each PID controller and map it to portfolio weights.

Results

The system performs extremely well, while being a low frequency strategy with very low turnover. This illustrates the effectiveness of the PID controller.

And, when comparing the edge of this system against an equally-weighted one of the current SP500 components, we see a steady edge:

And here’s how some of the assets’s PID controllers look like under the hood.

Getting the Code

Now, you have a fully working and highly profitable weekly rebalancing strategy based on the same principles that govern your thermostat. That’s pretty cool!

Get the Code!

If you want to play around with parameters, add your own tickers, etc, download the code above.

And if you're not a subscriber, subscribe as now!

Happy research!

In one of my last articles (here), I created an automated way to generate trading strategies and evaluate them for effectiveness. I was left with 164 base systems that were all unique, with many exceeding 20% CAGR after transaction fees.

However, most of the strategies were highly correlated because I was using a single basket to test the profitability. Thus, I decided to create 10x the strategies on a wide array of different baskets to solve this problem.

And while you may think that using the same systems with simply differing baskets would not change the performance drastically beyond 20% CAGR, I actually was able to achieve a system that beat the best expert in hindsight.

Here’s how I did it

10x’ing the Generation System

I already have a system that generates bespoke strategies and an evaluation system that tests to see if they are good or not.

So, I made a search system that generated a random basket of 10 stocks from the 69 S&P Dividend Aristocrat stocks and selected a random strategy from my generated strategy bank. It would then run that selection across the 4 lookback windows and 2 rebalancing times for a total of 8 variations.

Strategies that made 16% CAGR in-sample (from 2000 → 2020) after transaction fees of 10bps were kept. The others were thrown out.

Evaluating a batch took about 15 seconds. So, each strategy took only 0.25 seconds. I was able to generate a kept list of 1889 in about 25 minutes.

Evaluating the 1889 Strategies

I wrote a simple script to read all the backtests from all of the strategies and conglomerate them into a single results data structure that my backtesting platform portwine (GitHub repo here) can process. Writing a strategy that in real time steps through all 1889 strategies would take forever and I just wanted a sanity test for now. I averaged out the returns, and got this as a result:

Very impressive stuff! But I was worried about the risk of these strategies really taking their alpha from the best selected basked. Only 20% of strategies passed the scoring requirement of 16% CAGR, so I was concerned that those 20% shared similar stocks and that was why it was performing so well.

So, I counted the occurrences of each stock across all 1889 strategies.

I then calculated the proportion of each stock’s occurrence in comparison to all other stocks to create a weighed strategy to test my hypothesis.

Luckily, my fears turned out to be just fears. Allocating the proportion of the stock occurrences to a weighted strategy does not outperform the 1889 profitable strategies found.

Finding Correlation

1889 separate systems is extremely cumbersome to work with. So, I employed hierarchical clustering to find groups of strategies that were similar to each other but different from the rest. This gave me 25 different ‘families’ of systems that were unique.

Hierarchical clustering requires me to first calculate correlation between each strategy. Rather than using a simple Spearman’s correlation on the returns, I decided to do one on the drawdown curve instead.

This is because all the strategies trend upwards and to the right. They are highly correlated to each other as is. Looking at the drawdown not only gives us a better picture of the differences between each strategy, it also lets us attempt to find clusters that hedge against each other to create a better trading algorithm.

Even with this adaptation, it’s clear in the above correlation matrix that most strategies are still highly correlated with each other. But, this was good enough, as you will see.

Hierarchical Clustering

Hierarchical clustering groups data into ‘families,’ kind of like the tree of life.

Except, instead of species, it’s pieces of data. It finds common attributes from a high level, and then attempts to split the data where those attributes differ.

Running the drawdown correlation data on the hierarchical clustering algorithm set at 25 clusters worked surprisingly well. Below is a selection of 30 strategies and how that looks visualized in a dendrogram.

And here is the correlation matrix that is now much easier to read.

What is also great about clustering is that the size of each cluster varies. Therefore, similar, repeat strategies are no longer overcrowding our basket of trading strategies. We’ve boiled it down into 25 classes that all have unique traits.

Plotting Performance

I then plotted the top 10 clusters by performance to visualize how things went. Each equity curve is the average equity of all strategies in that particular cluster.

Our top performers all beat our current state-of-the-art strategy of all 1889 strategies bundled together.

The question now is how we allocate to these top performers so that we can take advantage of these clusters as they emerge as leaders. There is clearly have lookahead bias in the above chart, so I had to come up with an online way to achieve the same performance, or better, in real-time.

Beating the Best Strategy

I previously wrote about a metastrategy based on Tracking the Best Expert which is a strategy for following the best expert given changing dynamics. It works well. But, I continued researching and discovered a much better system that uses an autoregressive model to rank systems based on their recent momentum and allocates to the one’s posed to exhibit the most short term momentum.

I used data up to 2021-01-01 to get the best performing strategy from each cluster to get a basket of 25 systems. I then ran that through the metastrategy and plotted its results against our original uniform system and the best expert in hindsight.

The results speak for themselves. The Online Ridge-AR(1) system outperforms them all, especially in out-of-sample data.

Here are the final statistics:

Final wealth (full period)
  Best expert (hindsight)     : 3938.23
  Online Ridge-AR(1)          : 7032.76
  Uniform across experts      : 1265.78

Wealth multiples (t ≥ 2021-01-01)
  Best expert (hindsight)     :    0.99×
  Online Ridge-AR(1)          :    1.91×
  Uniform across experts      :    1.43×

And thus, we went from achieving 1265x our portfolio since 2000 by aggregating all of our 1889 strategies to over 7000x with clustering and a solid metastrategy.

Next Steps

Much like the 164 Trading Strategy catalog, expect a 1889 Trading Strategy catalog in the next week. If you want to dive into things yourself, I’ve uploaded all 1889 backtests (over 2GB) in the private Google Drive along with the code needed to replicate the systems constructed here.

View the Code

Happy trading and research!

We often have baskets of assets that we turn into trading strategies. But also, we have baskets of trading strategies that we need to allocate our capital into. In my last post (here), I demonstrated how to use generative AI to create a theoretically limitless supply of trading strategies. But, this is no good unless those strategies actually make money.

Backtests tell us what happened, but introduce data snooping. A metastrategy, an adaptive system that selects for us the best system(s) is a much better solution. I developed a bespoke algorithm based on deep research that gets us very close to the performance of the best strategy, or our theoretical outperformance.

Here’s how it works:

A Visual Example

Watch the video below:

What you see are 100 random strategies. Their performance is just randomly generated percentage gains and losses. They move down the track towards the finish line when their maximum equity increases. Thus, when each line is not moving, the strategy is in drawdown. The black lines highlight the top-10 performers at every given step.

Notice something peculiar: although these strategies are just random noise, at about half way though the race, the current leaders don’t change all too much. They continue to lead. The laggards are stuck in the back not contributing anything.

This is the same concept that I used to develop my universal metastrategy. I let the race run, but with real strategies, and then after a certain amount of time, take the top performers and only bet on them. It’s like letting the market decide for me who the winners are.

A Simple Application

In my last blog post, I generated 164 solid strategies which had 8 configurations for each (4 window lookbacks × 2 rebalance periods). To remove the manual aspect to it, I reverted to my original basket of 259 and calculated the returns for all 259 x 8 strategies (removing 2 for a total of 2070).

I then defined a ‘burn’ rate which is the amount of time we will let the strategies run before we select our to experts. Letting strategies run for a longer period of time gives the losers more time to wash away.

Above is that process. I select the top 20 experts after 2500 days of letting all 2070 run. Afterwards, only those top 20 are invested in (equally weighted). You can see the performance of that metastrategy versus an equally weighted metastrategy of all systems combined.

Now, we need to establish some baseline metrics to understand how good this approach is in general.

We can assume the worst metastrategy performs at an equally weighted portfolio of all strategies because that is the naive option. The best metastrategy is investing in the top strategy since day 1, as we cannot make any more money than that*.

* we can but I’m not going to go down that route this time.

Anyways, here’s how things would work with a burn cutoff period of 1,000 days and then short listing the top 20 assets, investing in all 20 equally.

Wealth multiples (t ≥ 1000)
  Best single expert (hindsight)                              :  71.94×
  Uniform across all experts                                  :  23.34×
  Uniform until t=1000, then 1/20 shortlist                   :  13.82×

Wow, this strategy is terrible. It performed worse than if we just equally invested in all 2070. I realized at this point that maybe my cute little pony-show concept was dead in the water. Until, I considered something else:

Why invest in all of the top strategies equally when we know that the performance between them all drifts? Some perform better some periods of time over others.

Thus, the capstone to my strategy was envisioned.

Betting on the ‘Horses’ Live

So, sure, I had a little setback. But that is never going to stop me from achieving my goals. It makes little sense to stick with a top-k equally weighted metastrategy if we know that the strategies ebb and flow in their performance.

I devised a simple rotational system that went something like this:

1. Every 75 days calculate which strategy did the best during the previous quarter out of our top-k shortlist.

2. Switch allocation 100% into that system and hold it for the next quarter.

This allows for a bit of adaptability without massive turnover that could hinder performance.

I should also remind you that these 2070 strategies are all highly correlated and share the same 10 - 12 assets in their universes. This also makes it a lot harder to come up with a metastrategy because there is not really a true uncorrelated ‘hedge’ when all strategies are similar. I will research diversification next.

The Results

Wealth multiples (t ≥ 1000)
  Best single expert (hindsight)                              :  71.94×
  Uniform across all experts                                  :  23.34×
  Uniform until t=1000, then 1/20 shortlist                   :  13.82×
  Uniform until t=1000, then adaptive shortlist               :  84.15×

Now we see spectacular performance. A little bit of adaptability allowed our metastrategy to compete and outperform the best expert in hindsight with no lookahead knowledge. This is great news and means that we can track the best expert and expect close performance with a combination of performance tracking and adaptability.

Implementing it Yourself

You can play with the algorithms yourself by simply bringing a matrix of strategy returns and dropping it into the system.

Check out the strategy code now in the private Google Drive. If you are not a paid subscriber, consider becoming one now to gain access to all of the previous strategies and code from all my other posts.

And if you enjoyed this post, remember to subscribe to get all my content straight to your inbox. I’m grateful for all of the support I’ve been shown thus far and look forward to bringing you all more high quality content.

Happy researching!

As mentioned in my last post (here), I designed and developed a way to quickly produce trading systems with the help of generative AI. And while this sounds like a recipe for disaster, because I constrained the problem to a very specific subset and I focused on only a few factors, the results were actually quite amazing.

From 875 candidate strategies, I manually filtered out 259 contenders. Using Principal Component Analysis, I discovered that many of those were ‘overlaps’ in terms of the factors they took advantage of. I condensed down that list to 164 new and bespoke portfolio allocation systems that often times outperform the state-of-the-art references I was using.

Here’s how I did it.

The Process

Ideation

The raw generation process was pretty simple. As I discussed in my previous post (here), I broke the problem down into a very specific and abstracted requirement. I only needed a single function to be developed. I had specifics for the format of the input, output, ranges for all the numbers, expectations, etc. So, I came up with a prompt that was clean, concise, and robust for generating ideas (see here). Each shot would generate 100 ideas at a time after I fed it into an LLM. I focused specifically on technical analysis systems to keep things simple.

The outputs were idea stubs that looked like this:

• Adaptive EMA Crossover

  • Uses a short and long EMA whose lengths adapt to recent volatility (higher vol → shorter EMAs).

  • Scores = current_price × (EMA_short/EMA_long).

• Volatility‐Scaled Momentum

  • Computes momentum over window and divides by recent realized volatility.

  • Scores ∝ momentum/σ, tilting toward stable strong trends.

• RSI Extremum Reversion

  • For each asset, RSI over window; if RSI>70, score = current_price×(1–(RSI–70)/30); if <30, score=current_price×(1+(30–RSI)/30); else current_price.

• Bollinger Band Trend

  • Build ±2σ bands on moving average; when price breaks above upper band, score = current_price×(1 + breach_pct); below lower, score=current_price×(1 – breach_pct); inside bands, revert to mean.

• Keltner Channel Fade

  • Uses ATR‐based channels; scores = channel_midpoint for inside moves, and for channel touches, score = current_price × (1 – sign(touch)k(distance/channel_width)).

Each of these stubs went into a single text file. I generated 875 unique strategies like this and felt like it was starting to just regurgitate the same type of system over and over again so I moved onto the implementation stage.

Implementation

I then used the same prompt, but slightly modified for code generation. I had it generate systems in batches of 20 at a time and output them all into an ‘implementation bank’ which was more or less just a list of files.

Verification

So 875 programmed strategies is pretty good. But I needed a way to sift through these all. I wrote a simple evaluator that read all of the files, extracted the classes, and ran them inside of my portwine backtesting system (available here).

The evaluator output an equity curve visualization, transaction fee analysis, and the raw outputs for later evaluation if I wanted to do anything with them in the future.

For a a chunk of the strategies, there were, unsurprisingly, errors. So, I had to debug and fix certain things, consolidate the code, etc. Even after this, some strategies were just malformed and had to be tossed out.

After getting outputs for as many strategies as I could, I had folders upon folders of images that I manually cycled through. I ran each strategy on a single basket of assets (CL, KO, PG, PEP, MMM, TGT, JNJ, LOW, MDT, MCD) to maintain simplicity, and 8 configurations of lookback windows and rebalancing periods (7 day lookback with weekly rebalance with 30 day lookback, monthly rebalance, etc.)

If a strategy outperformed the equal weight benchmark consistently for each of the configurations, it was kept. I tossed the rest. I was left with 259 strategies.

I then ran PCA analysis to understand how similar the strategies were. I found that 80% of the variance could be explained by just 14 systems, which is extremely concentrated. Note that there are 2070 strategies in this example because each parameter run is a seperate ‘strategy’ in this case.

To get rid of duplicates, I just ran a simple correlation filter to get rid of the highly correlated systems. A more sophisticated approach could have been taken that looked deeper into the PCA results, but this was good enough for me.

The final result? 164 kept strategies. 18.75%. Here’s how they looked.

The Strategies

The finalized strategies fell into the following categories with mean reversion and momentum being the most present. This is not surprising as the base models I used to create this meta-system used those two factors specifically.

• Mean Reversion Strategies

  • Prices are expected to revert to a central tendency after deviating.

• Trend Following / Momentum Strategies

  • Prices are expected to continue in their current direction.

• Moving Average Based Predictions (Direct Forecasting)

  • The MA itself (or a projection from it) is the price forecast.

• Statistical & Time Series Modeling

  • Employ formal statistical models to forecast prices.

• Signal Processing & Filtering Approaches

  • Apply filters to denoise price series or identify dominant frequencies.

• Pattern-Based & Event-Driven Strategies

  • Predictions triggered by specific chart patterns or events.

• Cross-Sectional Relative Value & Statistical Arbitrage

  • Exploit relative mispricings or co-movements among assets.

• Volatility & Range Based Strategies (as primary drivers)

  • Use volatility or price range characteristics directly to make predictions, not just for band construction.

Top 3 Strategies

Out of all 164 strategies, three stood out as clear winners, all achieving over 20% CAGR on monthly rebalancing strategies, which is extremely robust.

SquaredDiffMean

• Predicts price movement based on the normalized difference (SMA - EMA) / current_price. Predicted price = current_price * (1 + (SMA - EMA) / current_price). If SMA > EMA, implies upward prediction.

• Hyperparameters

  • 90-day Lookback

  • Monthly Rebalancing

• CAGR with fees: 21.80%

EntropyDivergence

• Calculates the Shannon entropy of an asset's returns. Low entropy suggests a trend, leading to a momentum-based prediction. High entropy suggests noise, leading to a mean-reversion prediction towards the moving average.

• Hyperparameters:

  • 90-day Lookback

  • Monthly Rebalance

• CAGR with fees: 20.95%

RecursiveEnvelope

• Recursively updates an envelope's center (EMA of current price with alpha) and its width (EMA of recent_vol / center with alpha). Predicts the current smoothed envelope center.

• Hyperparameters:

  • 180-day Lookback

  • Monthly Rebalancing

• CAGR: 20.38% with fees.

The Complete Catalog

For easy browsing, I created a simple static site that has the precomputed backtests of all the strategies for each of the timeframes. You can view all 164 strategies with all their 8 hyperparameter sets. Paid subscribers get access to every single strategy’s code in the private Google Drive repo.

You can view the catalog by clicking the button below:

View the Entire Catalog

If you enjoyed this post, make sure you subscribe for more great strategies and trading content right to your inbox. Your support means everything to me. Thanks so much! And for paid subscribers, the code is in the private drive:

Happy trading and research!

The $16,000,000 Windfall

In the evening of November 6, 2001, the stampeding hooves of horses against the grassy track and the roars of a frantic crowd filled the air of the Happy Valley Racecourse in Hong Kong. The energy was electric as the announcer roared into the microphone ‘And Bobo Duck has placed first, followed by Mascot Treasure, and Frat Rat! What a race!’ His voice echoed across the stadium, barely overcoming the frantic cheers.

Across the street, another electric energy was radiating 27 stories high as two Americans stared into the humming CRT monitor with their mouths agape.

“F---, we hit it,” one muttered.

Out of 51,381 bets that flashed on the screen, one managed to correctly predict the winning order of all three horses in all three heats, an over 10 million to one probability. The prize? $16 million. In cash.

And this was just the cherry on the cake. Bill Benter, the man who muttered at the screen, had been generating million annually since 1984 betting on horses.

But here’s the thing…

Benter wasn’t some big wig mathematician from the highest echelons of Ivy League society. He was a mid-western kid out of Pittsburg that got a physics degree in Cleveland, Ohio from Case Western Reserve. Hardly an exceptional story.

Yet, through his perseverance and ingenuity, he amassed over $1,000,000,000 (one billion) in cash profits, all from horse betting.

So how did he do it?

Humble Origins

Benter was born in 1957 in the nondescript suburbs of Pittsburgh, Pennsylvania. Not much is known about his familial life except that his parents are hardly exceptional. Bill went on to study physics in Cleveland, Ohio at a respectable, but reasonable college.

But something happened to Benter in college. He picked up Beat the Dealer by Ed Thorp that outlined how to count cards. Young and dumb, and with a brain that could calculate a thing or too, Bill hit the casinos.

And hit them he did. Within 7 years of counting cards, he was banned from most casinos in America. But he was hooked. The thrill of beating a system that was supposedly impossible to beat was the ultimate high. It was the ultimate David versus Goliath analogy: one man against the house and somehow squeaking out ahead.

But without access to blackjack, Benter had to improvise. To get his fix, he switched to horse races. Unlike blackjack, horse racing was a dynamic and unpredictable system. Each horse came from a different pedigree, ridden by a different jockey, trained by a different trainer. All with their own subjective approaches towards success.

Yet, Bill had a hunch that he, and he alone, could decipher the troves of data and read it like a Rosetta stone. Bold move, but he was a mathematician, not a reasonable person.

Cracking The Code

Benter very quickly started to pick up a pattern. One day, as he was trying to figure out how the casinos calculated the payout odds based on his historical data, he noticed that often times the casinos were paying better odds than what the data was telling him would happen.

A horse that was paying 25-1 actually had a 20-1 probability of winning. But Vegas was matching the sides of the market and taking a commission in the middle. The odds were being left up to the market which was clearly ill-informed.

A rush washed over Benter. He had just cracked the code. Sure, a 20-1 bet still is going to lose 95% of the time, but across 20 small bets, one will win. And he would make all those loses back, plus another 5x on top because the bet was paying 25-1.

Making A Billion Dollars, Cash

In 1984, Benter called up Alan Woods, a renowned Australian gambler. Benter would provide the skills: computer programming and modeling, which was unheard of at the time. Woods would bankroll the operation. The two agreed on terms and moved to Hong Kong to make it happen.

From ‘84 to ‘87, Benter’s system struggled. He suffered large financial losses. Technical issues ran amuck. Woods was getting impatient. Had he been swindled by the jargon spewing whiz-kid?

But, in 1987, Bill’s system finally reached profitability. During the ‘87 season, he had earned over $100,000, over $250,000 in today’s money.

With the base model generating income, Bill went on to tune and solidify his system. He used over 100 variables per horse, including speed, jockey performance, track condition, and even weather, to come up with the ultimate predictive model. Methods such as Monte Carlo, Bayesian inference, and specifically the Kelly Criterion were integral to taking the predictions and turning it into real money.

As his operation grew, Woods dropped out due to financial disagreements. New partners came and went. Bill’s office was staffed with employees who were rewinding and watching VHS tapes of horse races to calculate all the needed features for his system.

From first making money in 1987 until his retirement in 2001, just 14 years, Benter amassed over $1,000,000,000 in cash. That’s over $70,000,000 in hard money every year.

Lessons Learned

Bill’s story isn’t special. He didn’t make any earth shattering breakthroughs. He simply applied the science of statistics to something that hadn’t done before. He used the newest technology that gave him an edge.

But it’s important to remember:

1. He was not the casino. He beat the house at their own game.

2. Casinos were not using computers to price their bets when Bill started his career.

Assuming that the current dictators of the current order (casinos, in this case) are always up to date with the latest technology leaving you no room to compete is just as naive as assuming they aren’t. You are not doing yourself any good by being the cynic in your own brain shooting down every spark of ingenuity and joy.

What Bill did do was the following:

1. Remain humble.

2. Remain persistent.

3. Be obsessed.

4. Follow his moral compass.

Benter never ended up picking up that $16,000,000 bet from his triple top bet. Doing so, he said, would have been ‘unsportsmanlike.’

Benter retired shortly after and started a charity to give back to the small mid-western community he came from. His donations include helping fight to opioid crisis in America, Alzheimer’s research, supporting local theater and art programs, and local food banks.

There’s no salvation in the silver screen. Bill remains low-key. You might have never even heard of him before. And it’s safe to say that he sleeps more soundly at night than the media and attention hogs currently running circles around American political news channels, trying to fill the black hole void in the middle of their chest because they have lost all sense of morality and direction (you know who I’m talking about).

Be Like Bill

You sit in front of a computer or cell phone with thousands of times more processing power than what Benter had access to, even up to his retirement. And at your fingertips is a infinite wealth of knowledge, data, and information waiting to be combed through, waiting to be made into the model that has you walking out of a Hong Kong jockey club with a locked briefcase full of cash.

One man, one dream, one billion dollars.

And you can too. All you need to do is believe.

Sources

• https://www.linkedin.com/pulse/bill-benter-pioneer-data-analytics-ambalika-c-das-qxwic/

• https://www.wired.com/2002/03/betting

• https://medium.com/%40stockreporter/billionaire-bill-benter-the-professional-gambler-who-created-a-horse-racing-algorithm-to-predict-54ee78a81979

• https://www.bloomberg.com/news/features/2018-05-03/the-gambler-who-cracked-the-horse-racing-code

Everyone either naively thinks that an LLM will find alpha for them, or equally naively thinks LLMs cannot develop their own systems with any sort of edge. The reality is quite the opposite. When used properly, LLMs can supercharge your strategy research process by at least 10x. Those who aren’t using AI in their development workflows are going to be easily smoked by those who are in the next two years.

In this article, I’m going to outline how I broke down my last two strategy posts (OLMAR and LOAD) and used AI to come with completely new online portfolio selection algorithms. And the best part? It only took me 30 minutes.

But get this:

Some of the algorithms the AI developed performed better than the original algorithms themselves which were designed by state-of-the-art researchers. AI is no longer for toy problems and cute results.

Generalizing the Portfolio Selection Algorithm

I noticed that the OLMAR and LOAD algorithms were basically the same thing after writing both of my articles. Both of them use ‘price relatives’ as input features. Both of them create some sort of ‘forecast’ or scoring function for each asset based on technical features. Both of them project those scores onto a simplex (a list of weights that adds up to 1, or 100% of a portfolio).

I realized that the core of each of these algorithms was simply the ‘forecast’ or scoring function. The rest of them were exactly the same.

In the case of LOAD, that scoring function is:

1. If the slope of the last X prices is positive, return the percentage difference between the rolling maximum price of the asset and where the asset is currently trading.

2. If it is negative, return the percentage difference between the moving average of the asset and where the asset is currently trading.

In the case of OLMAR, that scoring function is:

1. The percentage difference between the moving average of the asset and where the asset is currently trading in all cases.

Those percentage differences are then projected on a simplex, which could also simply be conceptually seen as the proportion of the summed returns each asset is projected to achieve.

Thus, I created an abstract OnlinePortfolioSelectionAlgorithm that provides a single function to implement: the scoring function. So, I only needed the AI to come up with new scoring functions to plug in and the rest would work as expected.

Making the New Systems From Thin Air