Back to Community
Mean Reversion on Quantopian

A simple mean reversion strategy which is an adaptation of the Pipeline tutorial, "Putting it together". Excited that this adaptation was profitable, unlike the strategy in the tutorial. Grateful about what I currently know about the Pipeline API. Excited to learn more!!!

Clone Algorithm
Total Returns
Max Drawdown
Benchmark Returns
Returns 1 Month 3 Month 6 Month 12 Month
Alpha 1 Month 3 Month 6 Month 12 Month
Beta 1 Month 3 Month 6 Month 12 Month
Sharpe 1 Month 3 Month 6 Month 12 Month
Sortino 1 Month 3 Month 6 Month 12 Month
Volatility 1 Month 3 Month 6 Month 12 Month
Max Drawdown 1 Month 3 Month 6 Month 12 Month
from quantopian.algorithm import order_optimal_portfolio
from quantopian.algorithm import attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from import USEquityPricing
from quantopian.pipeline.factors import SimpleMovingAverage,ExponentialWeightedMovingAverage
from quantopian.pipeline.filters import QTradableStocksUS
import quantopian.optimize as opt

def initialize(context):
    # Schedule our rebalance function to run at the start of
    # each week, when the market opens.

    # Create our pipeline and attach it to our algorithm.
    my_pipe = make_pipeline()
    attach_pipeline(my_pipe, 'my_pipeline')

def make_pipeline():
    #The base universe filter
    base_universe = QTradableStocksUS()
    #10-day close price average [EWMA]
    ewma_5 = ExponentialWeightedMovingAverage(
                inputs = [USEquityPricing.close],
                window_length = 5,
                decay_rate = 0.15,
    ewma_20 = ExponentialWeightedMovingAverage(
                inputs = [USEquityPricing.close],
                window_length = 20,
                decay_rate = 0.15,
    #percent difference from the two averages
    percent_difference = (ewma_5 - ewma_20) / ewma_20
    #create a filter to select the securities to short
    shorts =
    #create a filter to select the securities to logn
    longs = percent_difference.bottom(75)
    #filter for the securities we want to trade
    securities_to_trade = (shorts | longs)
    return Pipeline(
        columns = {
            'longs': longs,
            'shorts': shorts
        screen = securities_to_trade

def compute_target_weights(context, data):
    Compute ordering weights.

    # Initialize empty target weights dictionary.
    # This will map securities to their target weight.
    weights = {}

    # If there are securities in our longs and shorts lists,
    # compute even target weights for each security.
    if context.longs and context.shorts:
        long_weight = 0.5 / len(context.longs)
        short_weight = -0.5 / len(context.shorts)
        return weights

    # Exit positions in our portfolio if they are not
    # in our longs or shorts lists.
    for security in context.portfolio.positions:
        if security not in context.longs and security not in context.shorts and data.can_trade(security):
            weights[security] = 0

    for security in context.longs:
        weights[security] = long_weight

    for security in context.shorts:
        weights[security] = short_weight

    return weights

def before_trading_start(context, data):
    Get pipeline results.

    # Gets our pipeline output every day.
    pipe_results = pipeline_output('my_pipeline')

    # Go long in securities for which the 'longs' value is True,
    # and check if they can be traded.
    context.longs = []
    for sec in pipe_results[pipe_results['longs']].index.tolist():
        if data.can_trade(sec):

    # Go short in securities for which the 'shorts' value is True,
    # and check if they can be traded.
    context.shorts = []
    for sec in pipe_results[pipe_results['shorts']].index.tolist():
        if data.can_trade(sec):

def my_rebalance(context, data):
    Rebalance weekly.

    # Calculate target weights to rebalance
    target_weights = compute_target_weights(context, data)

    # If we have target weights, rebalance our portfolio
    if target_weights:
There was a runtime error.