May 14th Quantopian Hackathon 2016¶
Agenda¶
- Contest Rules
- Submission Guidelines
- Judging Criteria
- Dataset Introductions w/ Sample Algorithm Templates
- Submission Template
Schedule¶
Hackathon 2016 Agenda
10AM – 11AM: Introduction to Quantopian, dataset showcases, and explanation of competition rules.
11AM – 12PM: Hackathon Start. Competitors will be free to ask Quantopian panelist questions.
12:00PM – 12:30PM: Lunch
12:30PM – 5:30PM: Hackathon Afternoon Session. Competitors will be free to ask Quantopian panelists questions.
5:30PM – 5:45PM: Final announcement of 6:00 submission deadline.
6:00PM – 6:30PM: Submission deadline, wrap-up.
Additionally, we reserve the right to disqualify any entry at our sole discretion. For instance, if we believe that an entry is made in bad faith with the intent to "game" the contest, or if we conclude that the algorithm is not following the rules presented in our contest rules and judging criteria.
Rules & Submission Guidelines¶
- At 6:00PM (or before then if you're ready), all contestants will be able to run their out-of-sample backtests.
- Your algorithm MUST use one of the PsychSignal datasets:
- data.psychsignal.twitter_withretweets_hackathon
- data.psychsignal.aggregated_twitter_withretweets_stocktwits_hackathon
- data.psychsignal.stocktwits_hackathon
- While you can use any of the three, you'll only be able to research factors with stocktwits_hackathon
- You will be able to run the full backtest over this time period by removing the `_hackathon` from your dataset import. This will only be possible once we begin allowing submissions.
- Contestants will be required to run a full backtest from January 1, 2011 up till May 12, 2016.
- Use the submission template found in this notebook to create your backtest tearsheet
- Download this notebook as an html file (by clicking Notebook at the top right -> Download as)
- Send the notebook along with your Name and Occupation to Hackathon@Quantopian.com using the email format below:
SUBJECT:
QuantCon Hackathon - [CONTESTANT NAME HERE]
BODY:
Here is my submission for QuantCon Hackathon 2016.
Name: [NAME]
Occupation: [OCCUPATION]
ATTACHED HTML NOTEBOOK AT BOTTOM- If you are a team, please only send one submission. Include the name and emails of each of your team members.
Judging Criteria¶
- Each algorithm will be graded from it's backtest score during January 1, 2011 up till May 12, 2016
- Each algorithm will receive a score based on two risk metrics:
- Sharpe: Higher sharpe the better
- Drawdown: Lower drawdown the better
- Each algorithm MUST have:
- Default Slippage & Commisions
- A beta between .3 and -.3
- Run in minutely mode
- Capital base of 1,000,000
- Average leverage 2.0 with maximum leverage under 2.5
Dataset Introductions w/ Template Algorithms¶
You do not have to use these templates but they are here for you to get started with.
In [14]:
from quantopian.pipeline import Pipeline
from quantopian.pipeline import CustomFactor
from quantopian.research import run_pipeline
from quantopian.pipeline.data import morningstar
from quantopian.pipeline.data.builtin import USEquityPricing
from quantopian.pipeline.factors import AverageDollarVolume
Hackathon Dataset: PsychSignal¶
PsychSignal: https://psychsignal.com/
Dataset Versions:
- Twitter - https://www.quantopian.com/data/psychsignal/twitter_withretweets
- StockTwits - https://www.quantopian.com/data/psychsignal/stocktwits
- Twitter & StockTwits - https://www.quantopian.com/data/psychsignal/aggregated_twitter_withretweets_stocktwits
Please use these namespaces for your development¶
In [32]:
from quantopian.pipeline.data.psychsignal import (
stocktwits_hackathon,
# twitter_withretweets_hackathon,
# aggregated_twitter_withretweets_stocktwits_hackathon
)
Take a look at what the data looks like through here
In [23]:
# PsychSignal
# This is the StockTwits (All Fields) dataset
from quantopian.pipeline.data.psychsignal import stocktwits_hackathon as psychsignal
pipe = Pipeline()
pipe.add(psychsignal.bull_scored_messages.latest, 'bull_messages')
pipe.add(psychsignal.bear_scored_messages.latest, 'bear_messages')
pipe.add(psychsignal.bullish_intensity.latest, "bullish_intensity")
pipe.add(psychsignal.bearish_intensity.latest, "bearish_intensity")
pipe.add(psychsignal.total_scanned_messages.latest, "total_messages")
output = run_pipeline(pipe, start_date='2014-01-04', end_date='2014-01-04')
output = output[output['total_messages'] > 10]
output.iloc[:5]
Out[23]:
Suggested Workflow¶
- Verify output with the code found in the Factor Output section of this notebook
- Research Factor in Factor Output. Look for good IC content, especially across quantiles. Good example found here: https://www.quantopian.com/posts/creating-a-new-strategy-with-pipeline-factors-quantcon-presentation
- Plug Factor into the long-short algorithm found above
Factor Research¶
See Factor Output¶
In [33]:
# Sample Factor
from quantopian.pipeline.data.psychsignal import stocktwits_hackathon as psychsignal
class Factor(CustomFactor):
"""
Baseline PsychSignal Factor
"""
inputs = [psychsignal.bull_minus_bear]
window_length = 1
def compute(self, today, assets, out, bull_minus_bear):
out[:] = bull_minus_bear
In [34]:
pipe = Pipeline()
factor = Factor()
# Screen out penny stocks and low liquidity securities.
dollar_volume = AverageDollarVolume(window_length=20)
is_liquid = dollar_volume.rank(ascending=False) < 1000
# Create the mask that we will use for our percentile methods.
base_universe = (is_liquid)
# Filter down to stocks in the top/bottom 10% by sentiment rank
longs = factor.rank().percentile_between(90, 100, mask=base_universe)
shorts = factor.rank().percentile_between(0, 10, mask=base_universe)
# Add Accern to the Pipeline
pipe.add(factor, "factor")
pipe.add(longs, "longs")
pipe.add(shorts, "shorts")
# Set our pipeline screens
pipe.set_screen((longs | shorts) & (factor != 0))
# Get the output of the pipeline
pipe_output = run_pipeline(pipe, start_date='2015-03-30', end_date='2015-03-30')
In [35]:
pipe.show_graph(format='png')
Out[35]:
In [36]:
pipe_output.iloc[0]
Out[36]:
Run Factor Tearsheet¶
Go here: https://www.quantopian.com/posts/factor-tear-sheet
Plug into template Long-Short Algorithm¶
This algorithm makes it very easy for you to plug Factors into. There's even code to combine multiple factors into an equally weighted scale.
In [37]:
import pandas as pd
import numpy as np
from quantopian.algorithm import attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from quantopian.pipeline.factors import CustomFactor, AverageDollarVolume
from quantopian.pipeline.data.psychsignal import (
stocktwits_hackathon,
# twitter_withretweets_hackathon,
# aggregated_twitter_withretweets_stocktwits_hackathon
)
# Factor belongs here
def make_pipeline():
# Create our pipeline
pipe = Pipeline()
# Screen out penny stocks and low liquidity securities.
dollar_volume = AverageDollarVolume(window_length=20)
is_liquid = dollar_volume.rank(ascending=False) < 1000
# Create the mask that we will use for our percentile methods.
base_universe = (is_liquid)
# Filter down to stocks in the top/bottom 10% by sentiment rank
factor = Factor()
longs = factor.rank().percentile_between(90, 100, mask=base_universe)
shorts = factor.rank().percentile_between(0, 10, mask=base_universe)
# Multiple Factors
# factor = Factor()
# factor_2 = Factor_2()
# combined_factor = (
# factor.rank(mask=base_universe) +
# factor_2.rank(mask=base_universe)
# )
# longs = combined_factor.rank().percentile_between(90, 100)
# shorts = combined_factor.rank().percentile_between(0, 10)
# Add Accern to the Pipeline
pipe.add(longs, "longs")
pipe.add(shorts, "shorts")
# Set our pipeline screens
pipe.set_screen((longs | shorts) & factor.notnan())
return pipe
# Put any initialization logic here. The context object will be passed to
# the other methods in your algorithm.
def initialize(context):
attach_pipeline(make_pipeline(), name='factors')
context.shorts = None
context.longs = None
# Create our scheduled functions
# This is a monthly rebalance, please change according to your
# frequency
schedule_function(rebalance, date_rules.month_start())
schedule_function(record_positions, date_rules.every_day(),
time_rules.market_close())
def before_trading_start(context, data):
# Assign long and short baskets
results = pipeline_output('factors')
if len(results.index) == 0:
log.info("Not Enough Data Yet!")
return
assets_in_universe = results.index
context.longs = assets_in_universe[results.longs]
context.shorts = assets_in_universe[results.shorts]
def record_positions(context, data):
# Record our leverage, exposure, positions, and number of open
# orders
record(lever=context.account.leverage,
exposure=context.account.net_leverage,
num_pos=len(context.portfolio.positions))
def rebalance(context, data):
if context.shorts is None or context.longs is None:
return
short_weight = -1.0/len(context.shorts)
long_weight = 1.0/len(context.longs)
assets_in_universe = (context.longs | context.shorts)
# Order our shorts
for security in context.shorts:
if data.can_trade(security):
order_target_percent(security, short_weight)
# Order our longs
for security in context.longs:
if data.can_trade(security):
order_target_percent(security, long_weight)
# Order securities not in the portfolio
for security in context.portfolio.positions:
if data.can_trade(security):
if security not in assets_in_universe:
order_target_percent(security, 0)
In [1]:
bt = get_backtest('573785ad82cd270f926abb5e')
bt.create_full_tear_sheet()
# Send to SLEE@QUANTOPIAN.COM
In [ ]: