Backtest from
to
with
initial capital
Total Returns
--
Alpha
--
Beta
--
Sharpe
--
Sortino
--
Max Drawdown
--
Benchmark Returns
--
Volatility
--
| 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 attach_pipeline, pipeline_output
from quantopian.pipeline import Pipeline
from quantopian.pipeline.data.builtin import USEquityPricing
from quantopian.pipeline.factors import Latest
from quantopian.pipeline.filters import StaticAssets,Q500US, make_us_equity_universe, Q1500US
from quantopian.pipeline import CustomFactor
from quantopian.pipeline.data.morningstar import asset_classification, valuation
from quantopian.pipeline.classifiers.morningstar import Sector
import numpy as np
from itertools import combinations
import statsmodels.api as statm
from statsmodels.tsa.stattools import adfuller
import pandas as pd
from scipy import odr
class check_and_get_pairs:
population_size = 300
max_pairs = 20
stationary_window = 63
signi_level = 0.05
deviation_cutoff = 1.
close_cutoff = 0.25
stop_loss = 6.0
margin = 0.1725
def __init__(self, context, data):
self.context = context
self.data = data
def get_pairs(self):
self.context.stock_list.loc[:,"isInt1"]= self.context.stock_list["sid"].map(lambda sec:self.check_Int1(sec))
self.context.stock_group=self.context.stock_list[ self.context.stock_list["isInt1"].values].\
groupby("industry")
self.context.paircount=0
for key, group in self.context.stock_group:
group_sids = group["sid"].tolist()
group_sids.sort(key=lambda x:x.sid)
if len(group_sids) > 1:
for pair in combinations(group_sids,2):
self.context.paircount+=1
if self.check_coint(pair):
self.context.today_pairs.append(pair)
if pair in self.context.pair_hist:
None
else:
self.context.pair_hist[pair]={}
self.context.pair_hist[pair]["stock1"]=pair[0].asset_name
self.context.pair_hist[pair]["stock2"]=pair[1].asset_name
self.context.pair_hist[pair]["profit"]=0
self.context.pair_hist[pair]["nTrades"]=0
self.context.pair_hist[pair]["weight"]=0
self.context.pair_hist[pair]["cur_weight"]=0
def get_weight(self, pair, dev_cutoff, dev_ceil = 3):
price_diff=self.context.price_hist[pair[0]].sub(self.context.price_hist[pair[1]])
mean_diff=price_diff.mean()
sd_diff=price_diff.std()
price1 = self.data.current(pair[0],"price")
price2 = self.data.current(pair[1],"price")
cur_diff = price1 - price2
cur_deviation = abs(cur_diff - mean_diff)/sd_diff
mprice=max(price1,price2)
weight=0
if (sd_diff/mprice > 0.1):
return 0
if (cur_deviation > dev_cutoff and cur_deviation < dev_ceil):
if (cur_diff > mean_diff):
data_x=self.context.price_hist[pair[0]]
data_y=self.context.price_hist[pair[1]]
weight=-1.0*self.get_beta(pair, data_x, data_y).beta[0]
else:
weight=(1.0)
return weight
def check_Int1(self, sid):
data_x = self.context.price_hist[sid].diff()[1:]
if data_x.isnull().any():
return False
else:
return self.is_stationary(data_x, self.signi_level)
def check_coint(self, pair):
data_x=self.context.price_hist[pair[0]]
data_y=self.context.price_hist[pair[1]]
return self.is_cointegrated(pair,data_x,data_y, self.signi_level)
def is_stationary(self, data_x, cutoff):
p_value = adfuller(data_x)[1]
if p_value < cutoff:
return True
else:
return False
def get_beta(self, pair, data_x, data_y, cutoff=0.01):
X=statm.add_constant(data_x)
linear_comb=statm.OLS(data_y,X)
fitted=linear_comb.fit()
const,beta=fitted.params
model = odr.Model(lambda B,x: (B[0]*x + B[1]))
data = odr.RealData(data_x, data_y, sx=np.std(data_x), sy=np.std(data_y))
myodr = odr.ODR(data, model, beta0=[beta, const])
myoutput = myodr.run()
return myoutput
def is_cointegrated(self, pair, data_x, data_y, cutoff=0.01):
myoutput = self.get_beta(pair, data_x, data_y)
spread = data_y - myoutput.beta[0] * data_x - myoutput.beta[1]
beta = myoutput.beta[0]
if (beta < 0 or beta > 2):
return False
else:
return self.is_stationary(spread,cutoff)
class trade_pairs(check_and_get_pairs):
def __init__(self, context, data):
self.context = context
self.data = data
def trade_algo(self):
weight_pos = [self.get_weight(pair,self.close_cutoff, self.stop_loss) for pair in self.context.pair_pos]
for ind, weight in enumerate(weight_pos):
if weight == 0:
self.close_pair(self.context.pair_pos[ind])
self.context.pair_pos=[pair for ind,pair in enumerate(self.context.pair_pos) if weight_pos[ind] !=0]
if len(self.context.pair_pos) == self.max_pairs:
return
else:
self.get_pairs()
value=self.context.portfolio.cash/self.max_pairs/self.margin
rel_weights=[]
for pair in self.context.today_pairs:
rel_weights.append( self.get_weight(pair, self.deviation_cutoff))
self.context.today_pairs=[ b for a,b in sorted(zip(rel_weights,self.context.today_pairs),
key= lambda x: abs(x[0]),reverse=True)]
rel_weights.sort(key=lambda x:-abs(x))
cur_pos= [sec.sid for stocks in self.context.pair_pos for sec in stocks]
for ind,pair in enumerate(self.context.today_pairs):
if rel_weights[ind] != 0:
if pair[0].sid in cur_pos or pair[1].sid in cur_pos:
rel_weights[ind] =0
else:
cur_pos.append(pair[0].sid)
cur_pos.append(pair[1].sid)
self.context.today_pairs=[ b for a,b in sorted(zip(rel_weights,self.context.today_pairs),
key= lambda x: abs(x[0]),reverse=True)]
rel_weights.sort(key=lambda x:-abs(x))
trade_count = self.max_pairs - len(self.context.pair_pos)
for ind,pair in enumerate(self.context.today_pairs[0:trade_count]):
if rel_weights[ind] != 0:
if (rel_weights[ind] <0):
amount = -value
else: #0보다 크면
amount=value
self.order_pair(pair,amount)
self.context.pair_pos.append(pair)
def order_pair(self, pair, value):
order_value(pair[0],value)
order_value(pair[1],-value)
def close_pair(self, pair):
for security in pair:
pos=self.context.portfolio.positions[security].amount
price = self.data.current(security, 'price')
init_price=self.context.portfolio.positions[security].cost_basis
profit=(price-init_price)*pos
self.context.pair_hist[pair]["profit"]+=profit
self.context.pair_hist[pair]["nTrades"]+=1
order_target_percent(pair[0],0)
order_target_percent(pair[1],0)
def initialize(context):
context.universe = Q500US()
context.pair_hist={}
context.pair_pos=[]
context.first_run=True
schedule_function(trade, date_rules.every_day(), time_rules.market_open(hours=1))
attach_pipeline(pipeline_data(context), 'fund_data')
def trade(context,data):
trading = trade_pairs(context,data)
trading.trade_algo()
def before_trading_start(context, data):
context.stock_list = pipeline_output('fund_data')
context.stock_list.loc[:,"sid"]=context.stock_list.index
context.today_pairs=[]
hist_price(context,data)
def hist_price(context,data):
if (context.first_run):
all_stocks=context.stock_list["sid"].tolist()
context.price_hist = data.history(all_stocks, "price", check_and_get_pairs.stationary_window, '1d')
context.first_run=False
else:
hist_stocks=context.price_hist.columns.tolist()
prev_price=data.history(hist_stocks, "price", 1, '1d')
context.price_hist = pd.concat([context.price_hist.iloc[1:,:],
prev_price])
hist_stock_ids=[sec.sid for sec in hist_stocks]
today_only_stocks=[sec for sec in context.stock_list["sid"] if sec.sid not in hist_stock_ids]
today_stock_hist = data.history(today_only_stocks, "price", check_and_get_pairs.stationary_window, '1d')
context.price_hist = pd.concat([context.price_hist,
today_stock_hist],axis=1)
def pipeline_data(context):
context.selection = make_us_equity_universe(check_and_get_pairs.population_size, rankby=valuation.market_cap.latest, mask=context.universe,max_group_weight=0.1, groupby=asset_classification.morningstar_industry_code.latest)
industry = asset_classification.morningstar_industry_code.latest
pipe_columns = {
'industry':industry
}
pipe = Pipeline(columns=pipe_columns,screen=context.selection)
return pipe
