Scoring based upon multiple conditions¶

# Import pipeline stuff
from quantopian.pipeline import Pipeline
from quantopian.research import run_pipeline, volumes, prices

# Import the data we need
from quantopian.pipeline.data import Fundamentals, USEquityPricing

# Import the filters and factors and classifiers we want to use
from quantopian.pipeline.factors import SimpleMovingAverage, ExponentialWeightedMovingAverage, Returns, MACDSignal, VWAP
from quantopian.pipeline.filters import QTradableStocksUS
from quantopian.pipeline.classifiers.fundamentals import Sector

# Import pandas and numpy because they rock
import pandas as pd
import numpy as np

# First create a pipeline to fetch all the data factors we need
def make_pipeline():
    # base universe filter
    base_universe = QTradableStocksUS()
    
    # factors
    roe = Fundamentals.roe.latest
    sma_200 = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=200, mask=base_universe)
    sma_20 = SimpleMovingAverage(inputs=[USEquityPricing.close], window_length=20, mask=base_universe)
    ema_9 = ExponentialWeightedMovingAverage(inputs=[USEquityPricing.close], window_length=9, decay_rate=0.875, mask=base_universe)
    ema_12 = ExponentialWeightedMovingAverage(inputs=[USEquityPricing.close], window_length=12, decay_rate=0.875, mask=base_universe)
    ema_26 = ExponentialWeightedMovingAverage(inputs=[USEquityPricing.close], window_length=26, decay_rate=0.875, mask=base_universe)
    macd = MACDSignal()
    volume = USEquityPricing.volume.latest
    price = USEquityPricing.close.latest
    average_volume = SimpleMovingAverage(inputs=[USEquityPricing.volume], window_length=200, mask=base_universe)
    recent_change = Returns(window_length=2, mask=base_universe)
    year_performance = Returns(window_length=365, mask=base_universe)
    month_performance = Returns(window_length=20, mask=base_universe)
    week_performance = Returns(window_length=5, mask=base_universe)
    eps = Fundamentals.basic_eps_earnings_reports.latest
    eps_growth = Fundamentals.diluted_eps_growth.latest
    
    # additional filters based upon above factors
    volume_filter = volume > 500000
    average_volume_filter = average_volume > 500000
    
    # redefine our universe
    universe = base_universe & volume_filter & average_volume_filter
    
    # create our pipeline with all the data factors
    return Pipeline(
        columns = {'roe' : roe,
                   'sma_200' : sma_200,
                   'sma_20' : sma_20,
                   'ema_9' : ema_9,
                   'ema_12' : ema_12,
                   'ema_26' : ema_26,
                   'macd' : macd,
                   'volume' : volume,
                   'price' : price,
                   'average_volume' : average_volume,
                   'recent_change' : recent_change,
                   'year_performance' : year_performance,
                   'month_performance' : month_performance,
                   'week_performance' : week_performance,
                   'eps' : eps,
                   'eps_growth' : eps_growth,
                   },
        screen = universe
    )

# run the pipeline
period_start = '2017-01-10'
period_end = '2018-06-10'

pipeline_output = run_pipeline(make_pipeline(), period_start, period_end)
pipeline_output

# Make a couple of helper functions to add and subtract from score
# This makes the rules easier to read
# Also, implements the try-except logic which would clutter the code a lot if in line

def add_to_score_if(rule, amount=1, df=pipeline_output, score_field='score'):
    try:
        df[score_field].loc[df.query(rule).index] += amount
    except:
        pass

def subtract_from_score_if(rule, amount=1, df=pipeline_output, score_field='score'):
    try:
        df[score_field].loc[df.query(rule).index] -= amount
    except:
        pass    

# Start by adding a column to the output for score
pipeline_output['score'] = 0



# Display the output. Notice the last column is the new calculated score
pipeline_output

# Rules to add and subtract from score
add_to_score_if('price > sma_200')
subtract_from_score_if('price <= sma_200')

add_to_score_if('roe > 0.1')

add_to_score_if('macd > 0') 
subtract_from_score_if('macd <= 0')

add_to_score_if('ema_9 > 0')
subtract_from_score_if('ema_9 <= 0')

add_to_score_if('year_performance > 0')
subtract_from_score_if('year_performance <= 0') 

# Verify the following logic is what's intended
add_to_score_if('month_performance > 0 and week_performance < 0 and ema_9 > 0')
subtract_from_score_if('month_performance < 0 and week_performance < 0 and ema_9 >= 0')

add_to_score_if('recent_change > 0')
subtract_from_score_if('recent_change <= 0')

add_to_score_if('eps > 0')
subtract_from_score_if('eps <= 0')

add_to_score_if('eps_growth > 0')
subtract_from_score_if('eps_growth <= 0')

pipeline_output

pricing_data = get_pricing(
  symbols=pipeline_output.index.levels[1], # Finds all assets that appear at least once in "factor_data"  
  start_date=period_start,
  end_date='2019-03-10', # must be after run_pipeline()'s end date. Explained more in lesson 4
  fields='open_price' # Generally, you should use open pricing. Explained more in lesson 4
)

# Show the first 5 rows of pricing_data
pricing_data.head(5)

from alphalens.utils import get_clean_factor_and_forward_returns

merged_data = get_clean_factor_and_forward_returns(
  factor=pipeline_output['score'], 
  prices=pricing_data, quantiles=2

)

# Show the first 5 rows of merged_data
merged_data.head(5)

from alphalens.tears import create_full_tear_sheet, create_information_tear_sheet

create_information_tear_sheet(merged_data)

from alphalens.tears import create_returns_tear_sheet

create_returns_tear_sheet(merged_data)