Savvy Investors Know Where to Get Their News—Do You?

Here’s the truth: Most financial media focuses on clicks, not clarity. The Daily Upside, created by Wall Street insiders, delivers valuable insights—free. Join 1M+ readers and subscribe today!

Join 1M+ readers and subscribe today!

Imagine the pleasure of growing a $200 investment into $432 within one year. The return is impressive, and that’s the goal for the 121 Model — a bespoke trading strategy that I had designed to combine the predictive power of deep learning with foundational principles in financial econometrics. Here are the essential ideas and methods that make the 121 Model different and how it uses machine learning to navigate the complexities of financial markets and generate signals based on subtle price movements.

The two concepts that underlie the 121 Model are cointegration and Long Short-Term Memory (LSTM) neural networks.

1. Cointegration: In financial markets, there are some asset pairs that have long-run relationships where their prices follow each other over time while experiencing short-term deviations. This is known as cointegration. The model takes advantage of this relationship by choosing a pair of highly correlated assets (in this case, Apple Inc. [AAPL] and Microsoft Corporation [MSFT]) and monitoring the spread between their prices. Despite such short-term deviations, however, cointegration theory suggests that such prices must move back to their equilibrium relation, providing a temporary trading opportunity.

2. Long Short-Term Memory (LSTM): A traditional statistical model can capture only a few aspects and cannot understand complex, nonlinear patterns in financial data. LSTM neural networks are specifically designed to handle sequential data, and learn from past trends to predict future movements. When you train the LSTM with the historical spread data would mean that the model will capture the patterns in those short-term deviations and, thereby, generate buy or sell signals based on returns back to the mean.

In other words, the 121 Model relies on cointegration to detect a set of pairs of assets with long-term equilibrium relationships and then applies LSTM to predict short-term deviations from that equilibrium. It is this dual approach that enables the model to leverage temporary price discrepancies to the tune of an impressive 121% annualized return.

I’ll take you through each step in the gathering of data, calculating the spread, preprocessing of the inputs, building of the model, and performance of the evaluation. On this journey, you’ll understand how financial principles of yore are improved through the usage of machine learning for developing a high returns-generating strategy. Let’s start now.

Fortune Favors The Bold

Ever wish you could turn back time and invest in Amazon's early days? Well, buckle up because the AI revolution is offering a second chance.

In The Motley Fool's latest report, dive into the world of AI-powered innovation. Discover why experts are calling it "the rocket fuel of AI" and predicting a market cap 41 times larger than Amazon's.

Don't let past regrets hold you back. Take charge of your future and capitalize on the AI wave with The Motley Fool's exclusive report.

Whether it's AI or Amazon, fortune favors the bold.

Don't miss out. Dive into the report today.

Data Download and Preparation

Our first step involves gathering historical adjusted close price data for AAPL and MSFT from Yahoo Finance, covering the period from January 2015 to October 2023. This data is essential to build, train, and test the model.

import pandas as pd
import yfinance as yf
import matplotlib.pyplot as plt

# Define ticker symbols and date range
ticker1 = 'AAPL'
ticker2 = 'MSFT'
start_date = '2015-01-01'
end_date = '2023-10-01'

# Download data
data1 = yf.download(ticker1, start=start_date, end=end_date)
data2 = yf.download(ticker2, start=start_date, end=end_date)

# Extract adjusted close prices and combine into a single DataFrame
df = pd.DataFrame({ticker1: data1['Adj Close'], ticker2: data2['Adj Close']})
df.dropna(inplace=True)

# Plot price series
plt.figure(figsize=(14, 7))
plt.plot(df[ticker1], label=ticker1)
plt.plot(df[ticker2], label=ticker2)
plt.title(f'Price Series of {ticker1} and {ticker2}')
plt.xlabel('Date')
plt.ylabel('Adjusted Close Price')
plt.legend()
plt.show()

Splitting Data into Training and Testing Sets

To evaluate the 121 Model, we split the data into a training set (2015–2020) and a testing set (2021–2023). This split ensures that the model is evaluated on unseen data for accurate performance assessment.

# Split data into training and testing sets
split_date = '2021-01-01'
train = df[:split_date]
test = df[split_date:]

print(f"Training data from {train.index[0].date()} to {train.index[-1].date()}")
print(f"Testing data from {test.index[0].date()} to {test.index[-1].date()}")

Cointegration Test on Training Data

Cointegration is a critical assumption in pairs trading, as it indicates a stable long-term relationship between two assets. The Engle-Granger cointegration test is applied here to evaluate whether AAPL and MSFT have a stable relationship over time.

from statsmodels.tsa.stattools import coint

# Perform cointegration test on training data
score, pvalue, _ = coint(train[ticker1], train[ticker2])
print(f'Cointegration test p-value: {pvalue:.4f}')

A p-value of 0.9557 suggests that AAPL and MSFT are not strictly cointegrated in a traditional sense. However, for the 121 Model, we proceed with the approach as it still captures valuable trading signals.

Estimating the Hedge Ratio

The hedge ratio quantifies the relationship between the two stocks and is used to calculate the spread between them. This ratio is estimated via linear regression, with MSFT as the independent variable and AAPL as the dependent variable.

from sklearn.linear_model import LinearRegression

# Hedge ratio estimation
X_train_lr = train[ticker2].values.reshape(-1, 1)
y_train_lr = train[ticker1].values
lr_model = LinearRegression()
lr_model.fit(X_train_lr, y_train_lr)
hedge_ratio = lr_model.coef_[0]
print(f'Hedge Ratio: {hedge_ratio:.4f}')

The hedge ratio for this model is 0.4658, indicating the proportion of MSFT that balances a position in AAPL.

Calculating the Spread

With the hedge ratio, we calculate the spread — the difference in price adjusted by the hedge ratio. This spread serves as the input data for the LSTM model, capturing deviations between AAPL and MSFT.

# Calculate the spread
df['Spread'] = df[ticker1] - hedge_ratio * df[ticker2]

Data Preprocessing (Scaling)

Before feeding the spread data to the LSTM, we normalize it to a range of 0–1 using MinMaxScaler. Scaling ensures that the LSTM can efficiently learn from the data without being affected by large numerical values.

from sklearn.preprocessing import MinMaxScaler

# Data preprocessing
scaler = MinMaxScaler(feature_range=(0, 1))
spread_values = df['Spread'].values.reshape(-1, 1)
scaled_spread = scaler.fit_transform(spread_values)
train_size = len(train)
train_spread = scaled_spread[:train_size]
test_spread = scaled_spread[train_size:]

Creating Sequences for the LSTM Model

To enable the LSTM to learn temporal patterns, we organize the spread data into sequences. Each sequence represents a sliding window of spread values, allowing the model to learn from recent history. In this case, we use 30-day sequences as the input to the LSTM.

# Function to create sequences
def create_sequences(data, time_steps=30):
    X = []
    y = []
    for i in range(len(data) - time_steps):
        X.append(data[i:(i + time_steps), 0])
        y.append(data[i + time_steps, 0])
    return np.array(X), np.array(y)

# Generate training sequences
time_steps = 30
X_train_seq, y_train_seq = create_sequences(train_spread, time_steps)
X_train_seq = X_train_seq.reshape((X_train_seq.shape[0], X_train_seq.shape[1], 1))

Building and Training the LSTM Model

The LSTM model serves as the core of the 121 Model, processing the spread sequences to predict future movements. We configure the model to learn from historical spread data, using a single LSTM layer and a dense output layer.

# LSTM model architecture
model = Sequential()
model.add(LSTM(50, input_shape=(X_train_seq.shape[1], 1)))  # Crucial hyperparameters not shared
model.add(Dense(1))
model.compile(loss='mean_squared_error', optimizer='adam')

# Model training (placeholder values)
history = model.fit(X_train_seq, y_train_seq, epochs=25, batch_size=32, verbose=1)

Note: Only the model architecture is shared here, without exposing crucial hyperparameters or sensitive details.

Making Predictions on Testing Data

With the trained model, we proceed to make predictions on the testing dataset. We prepare testing sequences and transform the predicted and actual values back to their original scales for evaluation.

# Prepare test data and make predictions
combined_spread = np.vstack((train_spread[-time_steps:], test_spread))
X_test_seq, y_test_seq = create_sequences(combined_spread, time_steps)
X_test_seq = X_test_seq.reshape((X_test_seq.shape[0], X_test_seq.shape[1], 1))

# Predict and invert scaling
predictions = model.predict(X_test_seq)
predictions_inv = scaler.inverse_transform(predictions)
y_test_seq_inv = scaler.inverse_transform(y_test_seq.reshape(-1, 1))

Plotting Candlestick Chart with Buy and Sell Signals

To visualize the signals on AAPL’s price chart, we prepare a candlestick plot with markers for buy and sell points. This chart illustrates the trading actions suggested by the model.

# Plot buy and sell signals on AAPL price chart
buy_signals = data1_test_signals[data1_test_signals['Signal'] == 1]
sell_signals = data1_test_signals[data1_test_signals['Signal'] == -1]

# Set buy/sell prices slightly above/below actual prices for visibility
signal_markers.loc[buy_signals.index, 'Buy'] = data1_test_signals.loc[buy_signals.index, 'Low'] * 0.99
signal_markers.loc[sell_signals.index, 'Sell'] = data1_test_signals.loc[sell_signals.index, 'High'] * 1.01

mpf.plot(data1_test_signals, type='candle', addplot=apds, title='AAPL Price with Buy and Sell Signals')

Calculating Strategy Returns

To evaluate the profitability, we calculate daily strategy returns based on the model’s signals and the asset returns. These returns are then compounded to derive cumulative strategy returns.

# Calculate daily returns and cumulative strategy returns
returns = df[[ticker1, ticker2]].pct_change().loc[test_df.index]
test_df['Strategy_Return'] = test_df['Signal'] * (returns[ticker1] - hedge_ratio * returns[ticker2])
test_df['Cumulative_Strategy_Return'] = (1 + test_df['Strategy_Return'].fillna(0)).cumprod() - 1

Performance Metrics

We assess the model’s risk-adjusted return using key metrics like annualized return, volatility, Sharpe ratio, and maximum drawdown.

# Calculate performance metrics
annualized_return = daily_return_mean * 252
annualized_volatility = daily_return_std * np.sqrt(252)
sharpe_ratio = (annualized_return - risk_free_rate) / annualized_volatility
max_drawdown = test_df['Drawdown'].max()

Adjusting for Transaction Costs

To account for real-world trading expenses, we adjust the model’s returns by incorporating transaction costs per trade. This adjustment yields a more realistic view of net returns.

# Adjust for transaction costs
transaction_cost = 0.0005  # Placeholder for actual costs
test_df['Trades'] = test_df['Signal'].diff().abs()
test_df['Transaction_Costs'] = test_df['Trades'] * transaction_cost
test_df['Strategy_Return_Net'] = test_df['Strategy_Return'] - test_df['Transaction_Costs']
test_df['Cumulative_Strategy_Return_Net'] = (1 + test_df['Strategy_Return_Net'].fillna(0)).cumprod() - 1

# Calculate performance metrics after transaction costs
# Annualized Return after transaction costs
daily_return_mean_net = test_df['Strategy_Return_Net'].mean()
annualized_return_net = daily_return_mean_net * 252
print(f'Annualized Return (Net): {annualized_return_net:.2%}')

# Annualized Volatility after transaction costs
daily_return_std_net = test_df['Strategy_Return_Net'].std()
annualized_volatility_net = daily_return_std_net * np.sqrt(252)
print(f'Annualized Volatility (Net): {annualized_volatility_net:.2%}')

# Sharpe Ratio after transaction costs
sharpe_ratio_net = (annualized_return_net - risk_free_rate) / annualized_volatility_net
print(f'Sharpe Ratio (Net): {sharpe_ratio_net:.2f}')

# Maximum Drawdown after transaction costs
test_df['Cumulative_Max_Net'] = test_df['Cumulative_Strategy_Return_Net'].cummax()
test_df['Drawdown_Net'] = test_df['Cumulative_Max_Net'] - test_df['Cumulative_Strategy_Return_Net']
max_drawdown_net = test_df['Drawdown_Net'].max()
print(f'Maximum Drawdown (Net): {max_drawdown_net:.2%}')

Results:

Performance Results and Discussion

1. Raw Strategy Return vs. Net Strategy Return

The Cumulative Strategy Return graph demonstrates the growth of returns over time when implementing the strategy without transaction costs. However, real-world trading incurs costs that can significantly impact profitability. The Net Strategy Return chart incorporates these transaction costs, offering a realistic picture of the model’s performance.

Observation: Even after accounting for transaction costs, the model sustains a high cumulative return, which reinforces its robustness for practical application.

2. Performance Metrics Explanation

The table below summarizes the model’s risk-adjusted return metrics before and after transaction costs:

• Annualized Return: This indicates the strategy’s yearly growth rate. The slight decrease after transaction costs still yields a substantial return of over 116%.

• Annualized Volatility: The model maintains consistent volatility, indicating its stability in fluctuating market conditions.

• Sharpe Ratio: This ratio, which measures risk-adjusted return, remains strong at 5.96 after costs, suggesting that the model achieves excellent returns relative to its risk.

• Maximum Drawdown: The drawdown metric shows that the model experiences periods of decline. Adjusted for transaction costs, the drawdown improves, reflecting a more realistic and sustainable approach in practical scenarios.

These metrics collectively demonstrate the 121 Model’s effectiveness in balancing return potential with risk management.

Conclusion

The 121 Model demonstrates how traditional econometric principles, such as cointegration, can be paired with deep learning techniques like LSTM to produce a profitable trading strategy. The results, even after transaction costs, illustrate the potential for strong returns and manageable risk, highlighting how machine learning can transform quantitative finance.

For those looking to explore algorithmic trading or understand how machine learning applies to finance, the 121 Model offers a compelling case study. As I continue refining the model, I look forward to sharing future insights and updates.