Back to Community
Ranking System Computations

Is this possible in quantopian? Ranking stocks by given them a number and then combine different value rankings into a composite ranking? It looks a bit like the dollarvolume weighted universe, but how to give a number to a stock and how to re-normalization when different factors are combined. It is not the same as a Piotroski screen as this screens for some "hard" numbers, like ROA > 5% or something like that. That could eliminate stocks that score well on other value rankings and are still good candidates.

"Basically, rank computation is a straightforward task. For each factor (or formula), we sort companies from best to worst (with the user choosing, in each case, whether higher or lower tallies are to be deemed
better) and then convert each to a percentile score, a scale of 100 for the best to zero for the worst. When
multiple factors are used, we combine them into an overall rank based on user-supplied weights.
There are, however, two important subtleties that must be understood to know how we calculate the exact
numbers. (portfolio123)"

3 responses

Hi Jan,
We are testing a new API with this functionality on staging right now. We probably have another couple of weeks to finalize and polish it off, but keep your eyes open in the near term.



The material on this website is provided for informational purposes only and does not constitute an offer to sell, a solicitation to buy, or a recommendation or endorsement for any security or strategy, nor does it constitute an offer to provide investment advisory services by Quantopian. In addition, the material offers no opinion with respect to the suitability of any security or specific investment. No information contained herein should be regarded as a suggestion to engage in or refrain from any investment-related course of action as none of Quantopian nor any of its affiliates is undertaking to provide investment advice, act as an adviser to any plan or entity subject to the Employee Retirement Income Security Act of 1974, as amended, individual retirement account or individual retirement annuity, or give advice in a fiduciary capacity with respect to the materials presented herein. If you are an individual retirement or other investor, contact your financial advisor or other fiduciary unrelated to Quantopian about whether any given investment idea, strategy, product or service described herein may be appropriate for your circumstances. All investments involve risk, including loss of principal. Quantopian makes no guarantees as to the accuracy or completeness of the views expressed in the website. The views are subject to change, and may have become unreliable for various reasons, including changes in market conditions or economic circumstances.

This is something I've been very interested as well. Is the expectation that the to-be released API will allow us to define/adjust our stock universe on the fly based on rank computation? In other words allow us to constantly rotate in best of breed securities into a portfolio while rotating out securities which which are underperforming - basically just as a fund manager would. Thanks -JM

Hi Jan and Jonathan,
The pipeline API was launched today and should help with these types of strategies. You can read all about it here.

I've also attached an example that calculates two factors (one momentum based, the other liquidity) and then ranks the universe by those factors. It longs and shorts 5% of the resulting universe respectively.

Jonathan, to answer your question about defining and adjusting your universe on the fly based on rank computations. Yes, this is exactly what the pipeline API allows you to do. You can create custom factors, calculate them across the entire universe of 8000 equities, and then set your algorithm universe daily based on the results.

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
This example comes from a request in the forums. 
The post can be found here:

The request was: 

I am stuck trying to build a stock ranking system with two signals:
1. Trading Volume/Shares Outstanding.
2. Price of current day / Price of 60 days ago.
Then rank Russell 2000 stocks every month, long the top 5%, short the bottom 5%.


from quantopian.algorithm import attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from quantopian.pipeline import CustomFactor
from import USEquityPricing
from import morningstar

# Create custom factor #1 Trading Volume/Shares Outstanding
class Liquidity(CustomFactor):   
    # Pre-declare inputs and window_length
    inputs = [USEquityPricing.volume, morningstar.valuation.shares_outstanding] 
    window_length = 1
    # Compute factor1 value
    def compute(self, today, assets, out, volume, shares):       
        out[:] = volume[-1]/shares[-1]

# Create custom factor #2 Price of current day / Price of 60 days ago.        
class Momentum(CustomFactor):   
    # Pre-declare inputs and window_length
    inputs = [USEquityPricing.close] 
    window_length = 60
    # Compute factor2 value
    def compute(self, today, assets, out, close):       
        out[:] = close[-1]/close[0]
# Create custom factor to calculate a market cap based on yesterday's close
# We'll use this to get the top 2000 stocks by market cap
class MarketCap(CustomFactor):   
    # Pre-declare inputs and window_length
    inputs = [USEquityPricing.close, morningstar.valuation.shares_outstanding] 
    window_length = 1
    # Compute market cap value
    def compute(self, today, assets, out, close, shares):       
        out[:] = close[-1] * shares[-1]

def initialize(context):
    pipe = Pipeline()
    attach_pipeline(pipe, 'ranked_2000')
    # Add the two factors defined to the pipeline
    liquidity = Liquidity()
    pipe.add(liquidity, 'liquidity')
    momentum = Momentum()
    pipe.add(momentum, 'momentum')
    # Create and apply a filter representing the top 2000 equities by MarketCap every day
    # This is an approximation of the Russell 2000
    mkt_cap = MarketCap()
    top_2000 =
    # Rank factor 1 and add the rank to our pipeline
    liquidity_rank = liquidity.rank(mask=top_2000)
    pipe.add(liquidity_rank, 'liq_rank')
    # Rank factor 2 and add the rank to our pipeline
    momentum_rank = momentum.rank(mask=top_2000)
    pipe.add(momentum_rank, 'mom_rank')
    # Take the average of the two factor rankings, add this to the pipeline
    combo_raw = (liquidity_rank+momentum_rank)/2
    pipe.add(combo_raw, 'combo_raw') 
    # Rank the combo_raw and add that to the pipeline
    pipe.add(combo_raw.rank(mask=top_2000), 'combo_rank')
    # Set a screen to ensure that only the top 2000 companies by market cap 
    # with a momentum factor greater than 0 are returned
    pipe.set_screen(top_2000 & (momentum>0))
    # Scedule my rebalance function
    # set my leverage
    context.long_leverage = 0.50
    context.short_leverage = -0.50
def before_trading_start(context, data):
    # Call pipelive_output to get the output
    context.output = pipeline_output('ranked_2000')
    # Narrow down the securities to only the top 200 & update my universe
    context.long_list = context.output.sort(['combo_rank'], ascending=False).iloc[:100]
    context.short_list = context.output.sort(['combo_rank'], ascending=False).iloc[-100:]   

def handle_data(context, data):  
     # Record and plot the leverage of our portfolio over time. 
    record(leverage = context.account.leverage)
    print "Long List""\n" + str(context.long_list.sort(['combo_rank'], ascending=True).head(10)))
    print "Short List""\n" + str(context.short_list.sort(['combo_rank'], ascending=True).head(10)))

# This rebalancing is called according to our schedule_function settings.     
def rebalance(context,data):
    long_weight = context.long_leverage / float(len(context.long_list))
    short_weight = context.short_leverage / float(len(context.short_list))

    for long_stock in context.long_list.index:
        if long_stock in data:
  "ordering longs")
  "weight is %s" % (long_weight))
            order_target_percent(long_stock, long_weight)
    for short_stock in context.short_list.index:
        if short_stock in data:
  "ordering shorts")
  "weight is %s" % (short_weight))
            order_target_percent(short_stock, short_weight)
    for stock in context.portfolio.positions.iterkeys():
        if stock not in context.long_list.index and stock not in context.short_list.index:
            order_target(stock, 0)
We have migrated this algorithm to work with a new version of the Quantopian API. The code is different than the original version, but the investment rationale of the algorithm has not changed. We've put everything you need to know here on one page.
There was a runtime error.