FORECASTING STOCK RETURNS WITH BIG DATA AND MACHINE LEARNING¶
OVERVIEW:¶
LogitBot Inc. uses machine learning and other advanced technologies to deliver investment insights and predictive analytics to investors across multiple time horizons. We combine massive amounts of data into a graph of the world's financial information and employ sophisticated models to uncover hidden relationships in order to understand and predict how markets are likely to behave.
SUMMARY¶
We are excited to demonstrate to the Quantopian community how they can our predicted stock return model outputs as a valuable signal in systematic strategies. The predictions we are making available on Quantopian consider a large variety of predictors ranging from fundamental factors, historical returns to credit and interest rate spreads, commodity prices, fx fluctuations to forecast log returns at 5 day horizon.
SAMPLE STRATEGY¶
We have shared a trading strategy that utilizes the model forecasts to generate attractive returns. A 5 year backtest of the strategy on Quantopians platform results in: <br> Total Returns of 239.42%, vs SPY 112.4%<br> Alpha: 0.33<br> Beta: 0.18<br> Sharpe: 3.20<br> Sortino: 4.06<br>
Complete details of the backtest and link to the algorithm are available here:.
We have made a sample dataset with 1 year worth of data available here:
BACKGROUND¶
Time Series Prediciton¶
Traditional methods of time-series analysis are mainly concerned with decomposing data into deterministic and non-deterministic components, namely:
1) Trend : The long-term change in the mean level, eg. an increasing trend.
2) Seasonal Effects : Many financial and macro economic time series such as earnings, commodity prices and home sales exhibit seasonal variations.
3) Noisy Residuals: The remaining component after trend and cyclic variations have been removed from a dataset.
A large number of Linear and nonlinear statistical models have been proposed to predict time series. Examples include the Autoregressive model AR(n) and NARX which assume that the next value is a linear weighted sum of the past n values plus a random shock. A significant drawback of these models is that they interpret all the structure in a time series through linear correlation, which is rarely the case in real world applications.
Time Series Prediction as a Machine Learning Problem¶
An alternative to tradtional prediction methods, and LogitBot's preferred approach is to cast time series prediction as a supervised learning problem. In this context, learning algorirthms can be used to infer the complex, nonlinear relationships between the inputs and a desired output.
Our learning procedure entails:
1) Choosing a family of candidate algorithms which give good approximations of the unknown function. <br> 2) Building and selecting the optimal set of features to use to train the candidate models. Machine learning algorithms are known to degrade in performance (prediction accuracy) when faced with many inputs. Using all available features may negatively affect generalization performance, especially in the presence of irrelevant or redundant features.<br> 3) Selecting the model that best generalizes to previously unseen out-of-sample data
WALK THROUGH FOR A SINGLE SECURITY¶
We review the key steps we employ to build a predictive model using AAPL as an example
Import Libraries¶
import pytz
from datetime import datetime
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import zipline
import seaborn as sns
ASSEMBLING TRAINING DATA¶
Raw data includes descriptive information on the stock, historical end of day market data, various global benchmark indices, commoditiies prices, fx rates, economic data etc. It is ill advised to use raw data in training models for reasons described below.
ticker = "AAPL"
input_csv = "stock_data_{} US EQUITY_20060101_20160527.csv".format(ticker)
input_df = local_csv(input_csv, date_column = 'record_date',
use_date_column_as_index = True)
input_df = input_df.drop(['bbg_ticker'], axis = 1)
input_df = input_df.rename(columns ={'yahoo_ticker':'ticker'})
input_df.iloc[-1].T
Filter on the numerical data for correlation plots
numeric_df = input_df.select_dtypes(include=['int16', 'int32', 'int64', 'float16', 'float32', 'float64'])
THE PROBLEM WITH USING RAW INPUTS TO TRAIN MODELS¶
<font color="#FF2400"> The Heatmap and distribution plots below indicate that many of the raw inputs are highly correlated and would NOT be useful in a machine learning algorithm. Many machine learning algorithms are known to degrade in performance when faced with highly correlated input features.</font>
sns.heatmap(numeric_df.sample(frac = 1, axis = 1).corr(), xticklabels=False, yticklabels=False)
Distribution of pairwise correlations in sample raw data¶
corr_df = numeric_df.corr()
s = corr_df.unstack()
corr_pairs = s.order(kind="quicksort")
corr_pairs = corr_pairs.drop_duplicates()
corr_pairs = corr_pairs.dropna(axis = 0)
corr_pairs = corr_pairs[corr_pairs<1]
sns.distplot(corr_pairs)
OUR SOLUTION TO HIGHLY CORRELATED RAW INPUTS - FEATURE ENGINEERING¶
The goal of feature engineering is to find a set of predictors that maximize the amount of useful information going into model training while avoiding overfitting. Selecting good features creates simpler models that generalize well to different scenarios. LogitBot carefully constructs a large range of features which are relatively uncorrelated to train our models.
feat_df_csv = "training_data-training_feats-v1_2-{} US EQUITY_feat_data_20060101_20160527.csv".format(ticker)
feat_df = local_csv(feat_df_csv, date_column = 'record_date',
use_date_column_as_index = True, delimiter = '|')
Distribution of pairwise correlations in engineered features¶
<font color="#008080"> The features features we use in model train have significantly less correlation and contain a broader set of useful information for model training</font>
feat_corr_df = feat_df.corr()
s = feat_corr_df.unstack()
feat_corr_pairs = s.order(kind="quicksort")
feat_corr_pairs = feat_corr_pairs.drop_duplicates()
feat_corr_pairs = feat_corr_pairs.dropna(axis = 0)
feat_corr_pairs = feat_corr_pairs[feat_corr_pairs<1]
sample_corr = feat_df.sample(frac = 1, axis = 1).corr()
sns.heatmap(sample_corr, xticklabels=False, yticklabels=False)
sns.distplot(feat_corr_pairs)
TRAINING THE MODEL¶
Model training is an iterative and compute intensive process. The process involves choosing:<br> 1) the ideal family of learners for the problem (e.g. neural networks, support vector machines,regression trees)<br> 2) Selecting the best values of hyper parameters (e.g. number of hidden layers, number of hidden nodes in NN, number of neighbors in KNN, number oflevels in trees)<br> 3) Wether to combine several unbiased models into a hyrbid predictor<br>
The final outcome is typically the result of a compromise between different factors, like the quantitative measures, the personal experience of the designer and the effort required to implement a particular model in practice
A LOOK AT THE PREDICTIONS¶
Once a model is trained, it is useful to see how well it does at predicting the target. Numerous methods exist to evaluate the accuracy of models including mean square errror, mean absolute error, etc. Depending on the strategy the absolute error measure may not be as important as the model's ability to predict the direction or sign of future returns
pred_csv = "{}_predictions_20060101_20160527.csv".format(ticker)
pred_df = local_csv(pred_csv, date_column = 'date',
use_date_column_as_index = True)
pred_df = pred_df.rename(columns={'model_h':'model_prediction'})
yr = 2014 # change yr to see different periods
plot_df = pred_df[pred_df.index.year==yr]
plot_df[['act_log_ret', 'model_prediction']].plot()
plt.title('{} - {}'.format(ticker, yr), weight = 'bold')
plt.ylabel('Log Returns', weight = 'bold')
PUTTING IT ALL TOGETHER IN A SIMPLE STRATEGY¶
Strategy Summary¶
1) Trade Universe: 80 US Large Cap Stocks <br>
2) Trade Rules:
a) Open long position if forecasted 5 day return is above average<br>
b) Enter long position if forecasted 5 day return is below average<br>
c) Hold positions for at least 3 days<br>
Strategy Backtest Results¶
bt= get_backtest('5759d71edeb8630f86aadca1')
bt.create_full_tear_sheet()
