QuantConnect Research

This repository contains a collection of Jupyter notebooks and tutorials designed to demonstrate research methodologies using the QuantConnect LEAN platform. It is organized into several categories to help developers transition from theoretical research to production-ready trading strategies:

• Topical Events: Analysis of specific market movements and historical events.
• Idea Streams PodCast: Video-based deep dives into specific quantitative topics (e.g., Tail Risk Hedging, Nowcasting).
• Research 2 Production Notebook Series: A structured series of notebooks designed to guide you through the workflow of developing a research idea and preparing it for production implementation. Topics include Mean Reversion, Random Forest Regression, Kalman Filters, and LSTM.
• Analysis Examples: Concrete implementations of quantitative techniques such as Fundamental Factor Analysis, Mean-Variance Portfolio Optimization, and Pairs Trading.

The PortfolioOptimization class implements mean-variance optimization to find efficient asset allocations. It uses log returns to calculate annual returns and volatility, and employs scipy.optimize.minimize to find optimal weights.

Key Methods:

• opt_portfolio(): Maximizes the Sharpe ratio to find the optimal weights, return, and volatility.
• min_var_portfolio(): Finds the portfolio with the minimum possible volatility.
• efficient_frontier(mc_returns): Calculates the efficient frontier based on a range of target returns.
• mc_mean_var(): Uses Monte Carlo simulation to generate a feasible region of possible returns and volatilities.
• plot(): Visualizes the Monte Carlo simulation, the efficient frontier, the optimal portfolio, the minimum volatility portfolio, and the Capital Market Line (CML).

# Assuming log_return is a pandas DataFrame of log returns
# and risk_free_rate is a float
a = PortfolioOptimization(log_return, risk_free_rate=0, num_assets=len(symbols))

# Get optimal weights, return, and volatility
opt_weights, opt_return, opt_volatility = a.opt_portfolio()

# Visualize results
a.plot()

In regression models, multicollinearity occurs when independent variables are highly correlated, making it difficult for the model to distinguish their individual effects. Principal Component Analysis (PCA) solves this by mapping the dataset into a new space of linearly-independent, orthogonal vectors (principal components).

Using PCA provides two main benefits:

1. Eliminates Multicollinearity: The new dimensions are orthogonal.
2. Dimensionality Reduction: You can identify and keep only the components that contribute most to the variance, reducing the number of input variables.

To use PCA with a variance threshold, initialize sklearn.decomposition.PCA with a float between 0 and 1 for n_components. This tells PCA to select the number of components required to explain that percentage of the variance.

from sklearn.decomposition import PCA

# Initialize PCA to explain 95% of the variance
pca = PCA(n_components=0.95)

# Fit the model to your training data
pca.fit(training)

print(f'PCA No. Components: {pca.n_components_}')

To train a machine learning model on time-series financial data, you should transform raw OHLCV data into stationary features (like percentage changes) and create sliding window sequences.

Use a function similar to prep_data to:

1. Calculate percentage changes (pct_change()) to normalize the data.
2. Handle infinities and NaNs using pd.option_context('mode.use_inf_as_na', True).
3. Create a feature set where each sample consists of n_tsteps previous time steps to predict the target value at t + 1.

def prep_data(data, n_tsteps=5):
    # Normalize data using percentage change
    df = data.pct_change()

    # Drop NaNs and infinities
    with pd.option_context('mode.use_inf_as_na', True):
        df = df.dropna()

    features = []
    labels = []

    for i in range(len(df)-n_tsteps):
        # Flatten the window of n_tsteps into a single feature vector
        input_data = df.iloc[i:i+n_tsteps].values.flatten()
        features.append(input_data)
        # Target is the 'close' price at the next time step
        label = df['close'].iloc[i+n_tsteps]
        labels.append(label)

    return np.array(features), np.array(labels)

This guide outlines a workflow for testing the significance of fundamental factors (like PE Ratio or Book Value Yield) in explaining stock returns:

1. Universe Selection: Choose a basket of symbols (e.g., top stocks by dollar volume).
2. Data Acquisition:
   • Fetch fundamental data using GetFundamental.
   • Clean data: Fill NaNs with forward-fill (ffill), drop remaining NaNs, and transpose to have symbols as rows and dates as columns.
   • Filter for the last day of each month to align with monthly return calculations.
3. Price History: Fetch historical close prices for the selected symbols and a benchmark (e.g., SPY).
4. Portfolio Construction:
   • At the start of each month, rank stocks by the chosen factor.
   • Divide ranked stocks into $N$ portfolios (e.g., 5 portfolios).
   • Calculate the average monthly return for each portfolio.
5. Significance Testing: Evaluate the factor using:
   • Correlation: The correlation between portfolio returns and their rank.
   • Win/Loss Probability: The probability that the 'winning' portfolio (top rank) outperforms the benchmark and the 'loss' portfolio (bottom rank) underperforms it.
   • Excess Return: The difference between the portfolio's annual return and the benchmark's annual return.

To build a more resilient portfolio and limit drawdown, you can identify assets that have the lowest average absolute correlation with the rest of a selected group. This is achieved by calculating a correlation matrix from historical returns and ranking assets based on their mean absolute correlation scaled by their standard deviation (row.abs().mean() / row.abs().std()).

Follow these steps:

1. Fetch historical data for a list of tickers using QuantBook.
2. Calculate hourly (or other resolution) returns using .pct_change().
3. Pass the returns DataFrame to a ranking function to select the top num_assets with the lowest correlation scores.

# Define the ranking function
def GetUncorrelatedAssets(returns, num_assets):
    # Get correlation matrix
    correlation = returns.corr()

    # Find assets with lowest mean correlation, scaled by STD
    selected = []
    for index, row in correlation.iteritems():
        corr_rank = row.abs().mean()/row.abs().std()
        selected.append((index, corr_rank))

    # Sort and take the top num_assets
    selected = sorted(selected, key = lambda x: x[1])[:num_assets]
    return selected

# Setup QuantBook and fetch data
qb = QuantBook()
tickers = ["SQQQ", "TQQQ", "TVIX", "VIXY", "SPLV", "SVXY", "UVXY", "EEMV", "EFAV", "USMV"]
symbols = [qb.AddEquity(x, Resolution.Minute) for x in tickers]

# Fetch history and calculate returns
history = qb.History(qb.Securities.Keys, 150, Resolution.Hour)
returns = history.unstack(level = 1).close.transpose().pct_change().dropna()

# Get 5 assets with least overall correlation
selected = GetUncorrelatedAssets(returns, 5)
print(selected)