So, for at least the past 4 weeks, SPX has maintained itself in a 35 point range.  What this has done to band systems like the Bollinger Bands (red) and Keltner Channels (yellow) has set us up for a fairly rare occurrence.  Firstly, the Bollinger Bands width (upper band – lower band) has dropped below 30 SPX points.  This hasn't happened for several months.  Secondly, the Bollinger bands have turned fairly flat.  Lastly, the Bollinger Bands (BB) have worked their way inside the Keltner Channels (KC).

A good question is, how can one quantify this to look for a similar situation that has occurred in the past?  Ideally, we would like to see where this has happened in the past, and look at the result for clues as to what could happen in the present.  We could do this visually, but it would take a lot time staring at charts.  I will briefly go through how to develop a simple thinkscript indicator to indicate when this situation is occurring.

Firstly, it is fairly easy to check the BB band width.  You just subtract the LowerBand value from the UpperBand to get your width.

Secondly, to describe the flatness of a line, we want to use a derivative, or difference.  If we take the current upper band value and subtract the upper band value of the previous candle, we get the slope of that line.  In the chart above, what is in the lower portion of the chart are the derivatives of each band (upper BB', lower BB', upper KC', lower KC').  We want to find a time in the past where the derivatives are close to 0, implying BB/KC flatness.  We don't really care whether the slope is negative or positive because, since they are so close to 0, they imply flatness.  In order to disregard the sign of the derivative, we can use the AbsValue() function and compare it to a threshold to determine flatness.  Here is some pseudo-code for what we would be looking for:

AbsValue(UpperBBSlope) < threshold and AbsValue(LowerBBSlope) < threshold and 
AbsValue(UpperKCSlope) < threshold and AbsValue(LowerKCSlope) < threshold

If we look at our current BB/KC slope values, we want to check that the AbsValue of the current slopes of upper/lower BB/KC lines are less than a threshold, say, 2.5.  Then, we also want to check that we have been flat for some time.  To do this, we can verify that the slopes of BB/KC lines of the last three periods are less than another threshold, say, 1.  Please note that these thresholds are only applicable to the scale of SPX.  In SPX, the BB width is about 30 SPX points while in SPY, the BB width would be about 3 SPY points.  These thresholds must be adjusted in the code if you intend to use this with another ticker symbol.  If you were going from SPX to SPY, you could multiply the threshold and BB width by approximately 1/10 (since SPY is approximately 1/10 of SPX).  All this checking of band slopes is doing is making sure we are near 0 for the past 4 candles.

Finally, we want to check that the BB is inside the KC.  This is also fairly simple, we can check that UpperKC > UpperBB and LowerKC < LowerBB.

Now we have all of our conditions to give us a signal:

1- BB width is less than or equal to 30 points
2- AbsValue(UpperBBSlope) < 2.5 and AbsValue(LowerBBSlope) < 2.5
3- AbsValue(UpperKCSlope) < 2.5 and AbsValue(LowerKCSlope) < 2.5
4- AbsValue(UpperBBSlope[1]) < 1 and AbsValue(LowerBBSlope[1]) < 1
5- AbsValue(UpperKCSlope[1]) < 1 and AbsValue(LowerKCSlope[1]) < 1
6- AbsValue(UpperBBSlope[2]) < 1 and AbsValue(LowerBBSlope[2]) < 1
7- AbsValue(UpperKCSlope[2]) < 1 and AbsValue(LowerKCSlope[2]) < 1
8- AbsValue(UpperBBSlope[3]) < 1 and AbsValue(LowerBBSlope[3]) < 1
9- AbsValue(UpperKCSlope[3]) < 1 and AbsValue(LowerKCSlope[3]) < 1
10- UpperKC > UpperBB and LowerKC < LowerBB

Note that UpperBBSlope means the current slope of the upper BB while UpperBBSlope[1] means 1 period ago (and [2] for 2 periods ago, [3] for 3 periods ago, etc.).  We can combine this into an if statement in thinkscript and check that all conditions are met.  Again, in pseudo-code:

if condition 1 and conditions 2-9 and condition 10 are all true, return 1, otherwise return 0.

So our signal should be 0 all the time unless our conditions are all true in which case it should spike to 1.  To create this script, I used the existing BollingerBandsSMA and KeltnerChannels scripts that come with TOS.  I combined both BB & KC into one script, so I could use data from each.

So above we have our signal.  Let's look in the past to find similar occurrences.  Look familiar?

So, keep in mind this happened before in December 2005.   The candle action looks almost identical to where we are today.  Three white candles up and above the mid-lines of BB and KC.  Back in December 2005, SPX re-tested the lows of the range it had been in for about a month (like now) and made slightly new lows.  Will history repeat itself?  Probably not, but it would be nice to see a selloff into OPEX week for once.  So take away what you will from this past occurrence and keep in mind there is always the chance of a fake-out on a BB squeeze.  The bulls seem ready to take charge again and break the range to the upside, but a lonely bear can dream of a downside squeeze, right?

If you'd like, you can download the script here Download NewStudy7STUDY.

In light of Tim’s recent post on old school video games, the advancement in computing continues to amaze me and will probably continue to amaze at the same rate for many decades. Or not … because although sufficient enough to approximate, Moore’s “Law” has to hit a threshold eventually, no system is infinitely in perpetual motion because eventually you succumb to the laws of entropy. Anyway, I’d like to do a series of posts on neural networks. I’ll discuss a bit of history in this first post, and how we can apply them to a financial model that can efficiently estimate market movements.

In the late 1800s and early 1900s neural networks became a concept that tried to explain the functional behavior of the human mind. In the 1980s, the implementation of neural networks in computation experienced a boom with the rediscovery of a computable backpropagation algorithm. The idea of spontaneous order came about from Friedrich Hayek in 1950 suggesting that the brain behaves as a result of decentralized networks of simple building blocks we can call neurons.

The mind can be essentially thought of as a network that processes multiple input variables in parallel. A neural network modeled in a computer does the same. Imagine a model of the market that can take into account multiple input variables and learn from itself. One of the strengths of NNs is the ability to find patterns and irregularities as well as being able to learn from the inter-dependence and correlation of all the inputs. Equivalent to a biological neuron, we can create an artificial neuron with a mathematical model.

This is the basic building block of a neural network, the single neuron. As with a biological neuron, your axon terminals are your n inputs. They have weights w_1 through w_n and transfer signals (or stimuli) u_1 through u_n into the neuron. The weights can be thought of as weights of “importance” to each input. The neuron takes into account the sum of the weighted inputs along with an activation function (in this case a step function) which triggers an output z.

Neurons can be organized in various network structures but for our purposes of financial modeling, I will only consider feed-forward networks and recurrent networks. Feed-forward networks just describe the flow of information. Information is fed forward from the input(s) to output(s). Recurrent networks are networks that allow for feedback loops.

Let’s consider a simple NN model where we would like the output to be SPX daily. We consider the following three inputs to the model:

-Previous day’s EUR/USD exchange rate

-Previous day’s LIBOR rate

-Previous day’s SPX close

The hidden layer of the network allows the network to learn not only how the inputs affect the output, but how each input affects other inputs. This model would be recurrent since the previous SPX data is fed back as an input. Using MATLAB, you can setup models like this. You can run a NN training where it analyzes past data and tests its forecast performance. Suppose we have 1000 data points of each input. That means 1000 daily closes of the EUR/USD, LIBOR, and SPX. We can set aside the first 70% of the data points for the network to “train” itself and compute all the weights (or importances) of each input. The remaining 30% of the data points can be used as a way to backtest predictions against actual outcomes. The network can analyze it's error rate and re-trains itself if the computed weights are not optimal.

Here is a model I have used so far and takes about 2-3 minutes to compute on my iMac (Intel Core 2 @ 2.4GHz, 2GB RAM). The model is a simple one with SPX past data as the input … no other inputs. The dataset used is on the lower-right chart. This is SPX daily close data since the 1970s (maybe 1979? forgot exactly what year the data started). The first 80% of the data was used for the NN training. The remaining 20% of the data was used to forecast (upper-left chart). The error in forecasting is shown on the lower-left chart. The 2-day forecast made by the NN on 11/13/2009 is on the upper-right chart. The model was saying we may get a slight drop the next day but after that, the trend was to change upward soon. I only chose to plot the output of two days because as you go out further in time, your error becomes exponentionally worse. Ideally, after each day, you would re-train the network so it is up to date with the latest data.

You can imagine a much more complex model with multiple outputs (SPX, Dow, Nasdaq, FTSE) and many more inputs (exchange rates, earnings, emerging market indices, volume, etc.). Other researchers have even used commonly used indicators as inputs to the NN model (MACD, RSI, moving averages, etc.). Increasing the inputs and hidden layers greatly increases the forecasting accuracy of the model while also increasing the computation time required. The computation required for this grows exponentially and you can start to see why the “little guy” is screwed from the start. The only way to profit 95%+ of each trading day with this type of computational edge is by an institution with large amounts of capital, a sick artificial NN model running on huge server farms, and direct fiber optic hookups into the NYSE for ultra-low latency. I am quite sure I don’t need to name names on this one.

In a David vs. Goliath attempt, I want to create a NN model with help from fellow Slopers. Maybe we can have some suggestions and discussions on what inputs ultimately affect the output the most. I don’t want to model something that would take days to compute on my iMac so maybe you can list your top 5 things you think affect SPX daily performance the most. Excluding the LDI (we love you Lester), here is my guess as to which inputs could be most influential on the outcome of SPX each day:

-LIBOR rate

-U.S. 20+ Year Treasury Bond Index (TLT)

-TED Spread

-Price of Gold

-Price of Oil