def test_optimizer():
from jaqs_fxdayu.research import Optimizer
dv = DataView()
dv.load_dataview(dataview_folder)
mask = mask_index_member(dv)
can_enter, can_exit = limit_up_down(dv)
price = dv.get_ts('close_adj')
high = dv.get_ts('high_adj')
low = dv.get_ts('low_adj')
price_bench = dv.data_benchmark
optimizer = Optimizer(dataview=dv,
formula='- Correlation(vwap_adj, volume, LEN)',
params={"LEN": range(2, 4, 1)},
name='divert',
price=price,
high=high,
low=low,
benchmark_price=price_bench, # =None求绝对收益 #=price_bench求相对收益
period=30,
n_quantiles=5,
mask=mask,
can_enter=can_enter,
can_exit=can_exit,
commission=0.0008, # 手续费 默认0.0008
is_event=False, # 是否是事件(0/1因子)
is_quarterly=False) # 是否是季度因子 默认为False
ret_best = optimizer.enumerate_optimizer(target_type="top_quantile_ret", # 优化目标类型
target="Ann. IR", # 优化目标
in_sample_range=[20140101, 20160101], # 样本内范围 默认为None,在全样本上优化
ascending=False) # 是否按优化目标升序排列(从小到大)
def analyze_event():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
target_symbol = '600519.SH'
price = dv.get_ts('close_adj', symbol=target_symbol)
dv.add_formula('in_', 'open_adj / Delay(close_adj, 1)', is_quarterly=False)
signal = dv.get_ts('in_', symbol=target_symbol).shift(1, axis=0) # avoid look-ahead bias
# Step.4 analyze!
obj = SignalDigger(output_folder='../../output', output_format='pdf')
obj.create_single_signal_report(signal, price, [1, 5, 9, 21], 6, mask=None,
buy_condition={'cond1': {'column': 'quantile',
'filter': lambda x: x > 3,
'hold': 5},
'cond2': {'column': 'quantile',
'filter': lambda x: x > 5,
'hold': 5},
'cond3': {'column': 'quantile',
'filter': lambda x: x > 5,
'hold': 9},
})
def load_data(symbol):
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
df = pd.DataFrame()
df['close'] = dv.get_ts('close',
symbol=symbol,
start_date=20080101,
end_date=20171231)[symbol]
df['open'] = dv.get_ts('open',
symbol=symbol,
start_date=20080101,
end_date=20171231)[symbol]
df['high'] = dv.get_ts('high',
symbol=symbol,
start_date=20080101,
end_date=20171231)[symbol]
df['low'] = dv.get_ts('low',
symbol=symbol,
start_date=20080101,
end_date=20171231)[symbol]
df = df.dropna()
return df
def do_backtest():
# Load local data file that we just stored.
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
backtest_props = {
"start_date": dv.start_date, # start and end date of back-test
"end_date": dv.end_date,
"period": "month", # re-balance period length
"benchmark": dv.benchmark, # benchmark and universe
"universe": dv.universe,
"init_balance": 1e8, # Amount of money at the start of back-test
"position_ratio": 1.0, # Amount of money at the start of back-test
}
backtest_props.update(data_config)
backtest_props.update(trade_config)
# Create model context using AlphaTradeApi, AlphaStrategy, PortfolioManager and AlphaBacktestInstance.
# We can store anything, e.g., public variables in context.
trade_api = AlphaTradeApi()
strategy = AlphaStrategy(pc_method='market_value_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
bt.init_from_config(backtest_props)
bt.run_alpha()
# After finishing back-test, we save trade results into a folder
bt.save_results(folder_path=backtest_result_folder)
def do_livetrade():
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
props = {"period": "day", "strategy_no": 1044, "init_balance": 1e6}
props.update(data_config)
props.update(trade_config)
strategy = AlphaStrategy(pc_method='market_value_weight')
pm = PortfolioManager()
bt = AlphaLiveTradeInstance()
trade_api = RealTimeTradeApi(props)
ds = RemoteDataService()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm,
data_api=ds)
bt.init_from_config(props)
bt.run_alpha()
goal_positions = strategy.goal_positions
print("Length of goal positions:", len(goal_positions))
task_id, msg = trade_api.goal_portfolio(goal_positions)
print(task_id, msg)
def analyze_event():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.2 calculate mask (to mask those ill data points)
mask_limit_reached = dv.get_ts('mask_limit_reached')
mask_index_member = dv.get_ts('mask_index_member')
mask_sus = dv.get_ts('mask_sus')
mask_all = np.logical_or(mask_sus, np.logical_or(mask_index_member, mask_limit_reached))
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
dv.add_formula('in_', '(Delay(index_weight, 1) == 0) && (index_weight > 0)', is_quarterly=False)
signal = dv.get_ts('in_').shift(1, axis=0) # avoid look-ahead bias
# Step.4 analyze!
obj = SignalDigger(output_folder='../../output', output_format='pdf')
obj.create_binary_event_report(signal, price, mask_all, price_bench, periods=[20, 60, 121, 242], group_by=None)
def do_livetrade():
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
props = {"period": "day",
"strategy_no": 1044,
"init_balance": 1e6}
props.update(data_config)
props.update(trade_config)
strategy = AlphaStrategy(pc_method='market_value_weight')
pm = PortfolioManager()
bt = AlphaLiveTradeInstance()
trade_api = RealTimeTradeApi(props)
ds = RemoteDataService()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm, data_api=ds)
bt.init_from_config(props)
bt.run_alpha()
goal_positions = strategy.goal_positions
print("Length of goal positions:", len(goal_positions))
task_id, msg = trade_api.goal_portfolio(goal_positions)
print(task_id, msg)
def analyze_event():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.2 calculate mask (to mask those ill data points)
mask_limit_reached = dv.get_ts('mask_limit_reached')
mask_index_member = dv.get_ts('mask_index_member')
mask_sus = dv.get_ts('mask_sus')
mask_all = np.logical_or(
mask_sus, np.logical_or(mask_index_member, mask_limit_reached))
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
dv.add_formula('in_',
'(Delay(index_weight, 1) == 0) && (index_weight > 0)',
is_quarterly=False)
signal = dv.get_ts('in_').shift(1, axis=0) # avoid look-ahead bias
# Step.4 analyze!
obj = SignalDigger(output_folder='../../output', output_format='pdf')
obj.create_binary_event_report(signal,
price,
mask_all,
price_bench,
periods=[20, 60, 121, 242],
group_by=None)
def add(formula, name):
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
dv.add_formula(name,
formula,
is_quarterly=False,
formula_func_name_style='lower')
dv.save_dataview(folder_path=dataview_dir_path)
def simple_test_signal():
dv = DataView()
dv.load_dataview(dataview_folder)
dv.add_formula('open_jump', 'open_adj / Delay(close_adj, 1)', is_quarterly=False) # good
analyze_signal(dv, 'open_jump', 'pdf')
print("Signal return & IC test finished.")
def test_backtest_analyze():
ta = ana.AlphaAnalyzer()
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
ta.initialize(dataview=dv, file_folder=backtest_result_dir_path)
ta.do_analyze(result_dir=backtest_result_dir_path, selected_sec=list(ta.universe)[:3])
def test_backtest_analyze():
ta = ana.AlphaAnalyzer()
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
ta.initialize(dataview=dv, file_folder=backtest_result_dir_path)
ta.do_analyze(result_dir=backtest_result_dir_path, selected_sec=list(ta.universe)[:3])
def test_add_field():
dv = DataView()
dv.load_dataview(folder_path=daily_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
ds = RemoteDataService()
ds.init_from_config(data_config)
dv.add_field('total_share', ds)
assert dv.data_d.shape == (nrows, ncols + 1 * n_securities)
def test_add_field():
dv = DataView()
dv.load_dataview(folder_path=daily_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
ds = RemoteDataService()
ds.init_from_config(data_config)
dv.add_field('total_share', ds)
assert dv.data_d.shape == (nrows, ncols + 1 * n_securities)
def test_alpha_strategy_dataview():
save_dataview()
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 0.7,
'commission_rate': 0.0
}
trade_api = AlphaTradeApi()
bt = AlphaBacktestInstance()
risk_model = model.FactorRiskModel()
signal_model = model.FactorSignalModel()
cost_model = model.SimpleCostModel()
stock_selector = model.StockSelector()
signal_model.add_signal(name='my_factor', func=my_factor)
cost_model.consider_cost(name='my_commission',
func=my_commission,
options={'myrate': 1e-2})
stock_selector.add_filter(name='total_profit_growth', func=my_selector)
stock_selector.add_filter(name='no_new_stocks',
func=my_selector_no_new_stocks)
strategy = AlphaStrategy(signal_model=signal_model,
stock_selector=stock_selector,
cost_model=cost_model,
risk_model=risk_model,
pc_method='factor_value_weight')
pm = PortfolioManager()
# strategy = AlphaStrategy(signal_model=signal_model, pc_method='factor_value_weight')
# strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='market_value_weight')
# strategy = AlphaStrategy()
context = model.AlphaContext(dataview=dv,
trade_api=trade_api,
instance=bt,
strategy=strategy,
pm=pm)
for mdl in [risk_model, signal_model, cost_model, stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def analyze_backtest_results():
# Analyzer help us calculate various trade statistics according to trade results.
# All the calculation results will be stored as its members.
ta = ana.AlphaAnalyzer()
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
ta.initialize(dataview=dv, file_folder=backtest_result_folder)
ta.do_analyze(result_dir=backtest_result_folder,
selected_sec=list(ta.universe)[:3])
def analyze_backtest_results():
# Analyzer help us calculate various trade statistics according to trade results.
# All the calculation results will be stored as its members.
ta = ana.AlphaAnalyzer()
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
ta.initialize(dataview=dv, file_folder=backtest_result_folder)
ta.do_analyze(result_dir=backtest_result_folder,
selected_sec=list(ta.universe)[:3])
def test_DIY_signal():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# 方法1：add_formula 基于dataview里已有的字段,通过表达式定义因子
dv.add_formula("momentum",
"Return(close_adj, 20)",
is_quarterly=False,
add_data=True)
# 方法2: append_df 构造一个因子表格（pandas.Dataframe）,直接添加到dataview当中
import pandas as pd
import talib as ta
close = dv.get_ts("close_adj").dropna(how='all', axis=1)
slope_df = pd.DataFrame(
{
sec_symbol: -ta.LINEARREG_SLOPE(value.values, 10)
for sec_symbol, value in close.iteritems()
},
index=close.index)
dv.append_df(slope_df, 'slope')
dv.get_ts("slope")
# 定义事件
from jaqs_fxdayu.research.signaldigger import process
Open = dv.get_ts("open_adj")
High = dv.get_ts("high_adj")
Low = dv.get_ts("low_adj")
Close = dv.get_ts("close_adj")
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status != 1
# 剔除掉停牌期的数据 再计算指标
open_masked = process._mask_df(Open, mask=mask_sus)
high_masked = process._mask_df(High, mask=mask_sus)
low_masked = process._mask_df(Low, mask=mask_sus)
close_masked = process._mask_df(Close, mask=mask_sus)
from jaqs_fxdayu.data import signal_function_mod as sfm
MA5 = sfm.ta(ta_method='MA',
ta_column=0,
Open=open_masked,
High=high_masked,
Low=low_masked,
Close=close_masked,
Volume=None,
timeperiod=10)
MA10 = sfm.ta('MA', Close=close_masked, timeperiod=10)
dv.append_df(MA5, 'MA5')
dv.append_df(MA10, 'MA10')
dv.add_formula("Cross",
"(MA5>=MA10)&&(Delay(MA5<MA10, 1))",
is_quarterly=False,
add_data=True)
def analyze_signal():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.2 calculate mask (to mask those ill data points)
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status == u'停牌'.encode('utf-8')
df_index_member = dv.get_ts('index_member')
mask_index_member = ~(df_index_member > 0)
dv.add_formula('limit_reached',
'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095',
is_quarterly=False)
df_limit_reached = dv.get_ts('limit_reached')
mask_limit_reached = df_limit_reached > 0
mask_all = np.logical_or(
mask_sus, np.logical_or(mask_index_member, mask_limit_reached))
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
# dv.add_formula('illi_daily', '(high - low) * 1000000000 / turnover', is_quarterly=False)
# dv.add_formula('illi', 'Ewma(illi_daily, 11)', is_quarterly=False)
# dv.add_formula('size', 'Log(float_mv)', is_quarterly=False)
# dv.add_formula('value', '-1.0/pb', is_quarterly=False)
# dv.add_formula('liquidity', 'Ts_Mean(volume, 22) / float_mv', is_quarterly=False)
dv.add_formula('divert',
'- Correlation(vwap_adj, volume, 10)',
is_quarterly=False)
signal = dv.get_ts('divert').shift(1, axis=0) # avoid look-ahead bias
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
# Step.4 analyze!
my_period = 5
obj = SignalDigger(output_folder='../../output/test_signal',
output_format='pdf')
obj.process_signal_before_analysis(
signal,
price=price,
mask=mask_all,
n_quantiles=5,
period=my_period,
benchmark_price=price_bench,
)
res = obj.create_full_report()
def test_add_formula():
dv = DataView()
dv.load_dataview(folder_path=daily_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
formula = 'Delta(high - close, 1)'
dv.add_formula('myvar1', formula, is_quarterly=False)
assert dv.data_d.shape == (nrows, ncols + 1 * n_securities)
formula2 = 'myvar1 - close'
dv.add_formula('myvar2', formula2, is_quarterly=False)
assert dv.data_d.shape == (nrows, ncols + 2 * n_securities)
def test_add_formula():
dv = DataView()
dv.load_dataview(folder_path=daily_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
formula = 'Delta(high - close, 1)'
dv.add_formula('myvar1', formula, is_quarterly=False)
assert dv.data_d.shape == (nrows, ncols + 1 * n_securities)
formula2 = 'myvar1 - close'
dv.add_formula('myvar2', formula2, is_quarterly=False)
assert dv.data_d.shape == (nrows, ncols + 2 * n_securities)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": BENCHMARK,
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "day",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
"strategy_no": 44
}
props.update(data_config)
props.update(trade_config)
stock_selector = model.StockSelector()
stock_selector.add_filter(name='rank_ret_top10', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector,
pc_method='equal_weight')
pm = PortfolioManager()
if is_backtest:
bt = AlphaBacktestInstance()
trade_api = AlphaTradeApi()
ds = None
else:
bt = AlphaLiveTradeInstance()
trade_api = RealTimeTradeApi(props)
ds = RemoteDataService()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm,
data_api=ds)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
if is_backtest:
bt.save_results(folder_path=backtest_result_dir_path)
else:
goal_positions = strategy.goal_positions
print(goal_positions)
def test_q_add_field():
dv = DataView()
dv.load_dataview(folder_path=quarterly_path)
nrows, ncols = dv.data_q.shape
n_securities = len(dv.data_d.columns.levels[0])
ds = RemoteDataService()
ds.init_from_config(data_config)
dv.add_field('net_inc_other_ops', ds)
"""
dv.add_field('oper_rev', ds)
dv.add_field('turnover', ds)
"""
assert dv.data_q.shape == (nrows, ncols + 1 * n_securities)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": "000300.SH",
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
trade_api.init_from_config(props)
def selector_growth(context, user_options=None):
growth_rate = context.snapshot['net_profit_growth']
return (growth_rate >= 0.2) & (growth_rate <= 4)
def selector_pe(context, user_options=None):
pe_ttm = context.snapshot['pe_ttm']
return (pe_ttm >= 5) & (pe_ttm <= 80)
stock_selector = model.StockSelector()
stock_selector.add_filter(name='net_profit_growth', func=selector_growth)
stock_selector.add_filter(name='pe', func=selector_pe)
strategy = AlphaStrategy(stock_selector=stock_selector,
pc_method='equal_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_q_add_field():
dv = DataView()
dv.load_dataview(folder_path=quarterly_path)
nrows, ncols = dv.data_q.shape
n_securities = len(dv.data_d.columns.levels[0])
ds = RemoteDataService()
ds.init_from_config(data_config)
dv.add_field('net_inc_other_ops', ds)
"""
dv.add_field('oper_rev', ds)
dv.add_field('turnover', ds)
"""
assert dv.data_q.shape == (nrows, ncols + 1 * n_securities)
def store_ic_weight():
"""
Calculate IC weight and save it to file
"""
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
factorList = ['TO', 'BP', 'REVS20', 'float_mv_factor']
orthFactor_dic = {}
for factor in factorList:
orthFactor_dic[factor] = {}
# add the orthogonalized factor to dataview
for trade_date in dv.dates:
snapshot = dv.get_snapshot(trade_date)
factorPanel = snapshot[factorList]
factorPanel = factorPanel.dropna()
if len(factorPanel) != 0:
orthfactorPanel = Schmidt(factorPanel)
orthfactorPanel.columns = [x + '_adj' for x in factorList]
snapshot = pd.merge(left=snapshot,
right=orthfactorPanel,
left_index=True,
right_index=True,
how='left')
for factor in factorList:
orthFactor_dic[factor][trade_date] = snapshot[factor]
for factor in factorList:
dv.append_df(pd.DataFrame(orthFactor_dic[factor]).T,
field_name=factor + '_adj',
is_quarterly=False)
dv.save_dataview(dataview_dir_path)
factorList_adj = [x + '_adj' for x in factorList]
jutil.save_json(factorList_adj, custom_data_path)
w = get_ic_weight(dv)
store = pd.HDFStore(ic_weight_hd5_path)
store['ic_weight'] = w
store.close()
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
#回测参数选择
props = {
"benchmark": "000905.SH",
"universe": ','.join(dv.symbol),
"start_date": 20170605,
"end_date": 20180807,
"period": "day",
"days_delay": 0,
"init_balance": 1e9,
"position_ratio": 1.0,
"commission_rate": 0.0015, #手续费
"n_periods": 2
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
signal_model = model.FactorSignalModel()
#添加信号
signal_model.add_signal('alpha3', alpha) #在使用新因子时，alpha3应改为新因子的名称
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myselector', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector,
signal_model=signal_model,
pc_method='factor_value_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
for mdl in [signal_model, stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": "000300.SH",
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
trade_api.init_from_config(props)
def selector_growth(context, user_options=None):
growth_rate = context.snapshot['net_profit_growth']
return (growth_rate >= 0.2) & (growth_rate <= 4)
def selector_pe(context, user_options=None):
pe_ttm = context.snapshot['pe_ttm']
return (pe_ttm >= 10) & (pe_ttm <= 20)
stock_selector = model.StockSelector()
stock_selector.add_filter(name='net_profit_growth', func=selector_growth)
stock_selector.add_filter(name='pe', func=selector_pe)
strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='equal_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_q_add_formula():
dv = DataView()
folder_path = '../output/prepared/20160609_20170601_freq=1D'
dv.load_dataview(folder_path=quarterly_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
formula = 'total_oper_rev / close'
dv.add_formula('myvar1', formula, is_quarterly=False)
df1 = dv.get_ts('myvar1')
assert not df1.empty
formula2 = 'Delta(oper_exp * myvar1 - open, 3)'
dv.add_formula('myvar2', formula2, is_quarterly=False)
df2 = dv.get_ts('myvar2')
assert not df2.empty
def test_q_add_formula():
dv = DataView()
folder_path = '../output/prepared/20160609_20170601_freq=1D'
dv.load_dataview(folder_path=quarterly_path)
nrows, ncols = dv.data_d.shape
n_securities = len(dv.data_d.columns.levels[0])
formula = 'total_oper_rev / close'
dv.add_formula('myvar1', formula, is_quarterly=False)
df1 = dv.get_ts('myvar1')
assert not df1.empty
formula2 = 'Delta(oper_exp * myvar1 - open, 3)'
dv.add_formula('myvar2', formula2, is_quarterly=False)
df2 = dv.get_ts('myvar2')
assert not df2.empty
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": BENCHMARK,
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "day",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
"strategy_no": 44
}
props.update(data_config)
props.update(trade_config)
stock_selector = model.StockSelector()
stock_selector.add_filter(name='rank_ret_top10', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='equal_weight')
pm = PortfolioManager()
if is_backtest:
bt = AlphaBacktestInstance()
trade_api = AlphaTradeApi()
ds = None
else:
bt = AlphaLiveTradeInstance()
trade_api = RealTimeTradeApi(props)
ds = RemoteDataService()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm, data_api=ds)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
if is_backtest:
bt.save_results(folder_path=backtest_result_dir_path)
else:
goal_positions = strategy.goal_positions
print(goal_positions)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": "000300.SH",
"universe": ','.join(dv.symbol),
"start_date": 20170131,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e9,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
def singal_gq30(context, user_options=None):
import numpy as np
res = np.power(context.snapshot['gq30'], 8)
return res
signal_model = model.FactorSignalModel()
signal_model.add_signal('signal_gq30', singal_gq30)
strategy = AlphaStrategy(signal_model=signal_model,
pc_method='factor_value_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
signal_model.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def analyze_event():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.2 calculate mask (to mask those ill data points)
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status == u'停牌'.encode('utf-8')
df_index_member = dv.get_ts('index_member')
mask_index_member = ~(df_index_member > 0)
dv.add_formula('limit_reached',
'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095',
is_quarterly=False)
df_limit_reached = dv.get_ts('limit_reached')
mask_limit_reached = df_limit_reached > 0
mask_all = np.logical_or(
mask_sus, np.logical_or(mask_index_member, mask_limit_reached))
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
dv.add_formula('new_high',
'close_adj >= Ts_Max(close_adj, 300)',
is_quarterly=False)
dv.add_formula('new_high_delay',
'Delay(Ts_Max(new_high, 300), 1)',
is_quarterly=False)
dv.add_formula('sig', 'new_high && (! new_high_delay)', is_quarterly=False)
signal = dv.get_ts('sig').shift(0, axis=0) # avoid look-ahead bias
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
# Step.4 analyze!
obj = SignalDigger(output_folder=jutil.join_relative_path('../output'),
output_format='pdf')
obj.create_binary_event_report(signal,
price,
mask_all,
5,
price_bench,
periods=[5, 20, 40])
def test_load():
dv = DataView()
dv.load_dataview(folder_path=daily_path)
assert dv.start_date == 20160601 and set(dv.symbol) == set('000001.SZ,600030.SH,000063.SZ'.split(','))
# test get_snapshot
snap1 = dv.get_snapshot(20170504, symbol='600030.SH,000063.SZ', fields='close,pb')
assert snap1.shape == (2, 2)
assert set(snap1.columns.values) == {'close', 'pb'}
assert set(snap1.index.values) == {'600030.SH', '000063.SZ'}
# test get_ts
ts1 = dv.get_ts('close', symbol='600030.SH,000063.SZ', start_date=20170101, end_date=20170302)
assert ts1.shape == (38, 2)
assert set(ts1.columns.values) == {'600030.SH', '000063.SZ'}
assert ts1.index.values[-1] == 20170302
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e8,
'commission_rate': 0.0
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
bt = AlphaBacktestInstance()
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myselector', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector,
pc_method='equal_weight')
pm = PortfolioManager()
context = model.AlphaContext(dataview=dv,
trade_api=trade_api,
instance=bt,
strategy=strategy,
pm=pm)
store = pd.HDFStore(ic_weight_hd5_path)
factorList = jutil.read_json(custom_data_path)
context.ic_weight = store['ic_weight']
context.factorList = factorList
store.close()
for mdl in [stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": "000300.SH",
"universe": ','.join(dv.symbol),
"start_date": 20170131,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e9,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
def singal_gq30(context, user_options=None):
import numpy as np
res = np.power(context.snapshot['gq30'], 8)
return res
signal_model = model.FactorSignalModel()
signal_model.add_signal('signal_gq30', singal_gq30)
strategy = AlphaStrategy(signal_model=signal_model, pc_method='factor_value_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
signal_model.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e8,
'commission_rate': 0.0
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
bt = AlphaBacktestInstance()
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myselector', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector,
pc_method='equal_weight')
pm = PortfolioManager()
context = model.AlphaContext(dataview=dv, trade_api=trade_api,
instance=bt, strategy=strategy, pm=pm)
store = pd.HDFStore(ic_weight_hd5_path)
factorList = jutil.read_json(custom_data_path)
context.ic_weight = store['ic_weight']
context.factorList = factorList
store.close()
for mdl in [stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def store_ic_weight():
"""
Calculate IC weight and save it to file
"""
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
factorList = ['TO', 'BP', 'REVS20', 'float_mv_factor']
orthFactor_dic = {}
for factor in factorList:
orthFactor_dic[factor] = {}
# add the orthogonalized factor to dataview
for trade_date in dv.dates:
snapshot = dv.get_snapshot(trade_date)
factorPanel = snapshot[factorList]
factorPanel = factorPanel.dropna()
if len(factorPanel) != 0:
orthfactorPanel = Schmidt(factorPanel)
orthfactorPanel.columns = [x + '_adj' for x in factorList]
snapshot = pd.merge(left=snapshot, right=orthfactorPanel,
left_index=True, right_index=True, how='left')
for factor in factorList:
orthFactor_dic[factor][trade_date] = snapshot[factor]
for factor in factorList:
dv.append_df(pd.DataFrame(orthFactor_dic[factor]).T, field_name=factor + '_adj', is_quarterly=False)
dv.save_dataview(dataview_dir_path)
factorList_adj = [x + '_adj' for x in factorList]
jutil.save_json(factorList_adj, custom_data_path)
w = get_ic_weight(dv)
store = pd.HDFStore(ic_weight_hd5_path)
store['ic_weight'] = w
store.close()
def test_analyze_signal():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
mask = mask_index_member(dv)
can_enter, can_exit = limit_up_down(dv)
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
dv.add_formula('divert',
'- Correlation(vwap_adj, volume, 10)',
is_quarterly=False,
add_data=True)
signal = dv.get_ts('divert')
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
# Step.4 analyze!
my_period = 5
obj = SignalDigger(output_folder='../output/test_signal',
output_format='pdf')
obj.process_signal_before_analysis(
signal=signal,
price=price,
high=dv.get_ts("high_adj"), # 可为空
low=dv.get_ts("low_adj"), # 可为空
group=dv.get_ts("sw1"),
n_quantiles=5, # quantile分类数
mask=mask, # 过滤条件
can_enter=can_enter, # 是否能进场
can_exit=can_exit, # 是否能出场
period=my_period, # 持有期
benchmark_price=price_bench, # 基准价格 可不传入，持有期收益（return）计算为绝对收益
commission=0.0008,
)
signal_data = obj.signal_data
result = analysis(signal_data, is_event=False, period=my_period)
ic = pfm.calc_signal_ic(signal_data, by_group=True)
mean_ic_by_group = pfm.mean_information_coefficient(ic, by_group=True)
plotting.plot_ic_by_group(mean_ic_by_group)
res = obj.create_full_report()
def do_backtest():
# Load local data file that we just stored.
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
backtest_props = {# start and end date of back-test
"start_date": dv.start_date,
"end_date": dv.end_date,
# re-balance period length
"period": "month",
# benchmark and universe
"benchmark": dv.benchmark,
"universe": dv.universe,
# Amount of money at the start of back-test
"init_balance": 1e8,
# Amount of money at the start of back-test
"position_ratio": 1.0,
}
backtest_props.update(data_config)
backtest_props.update(trade_config)
# We use trade_api to send orders
trade_api = AlphaTradeApi()
# This is our strategy
strategy = AlphaStrategy(pc_method='market_value_weight')
# PortfolioManager helps us to manage tasks, orders and calculate positions
pm = PortfolioManager()
# BacktestInstance is in charge of running the back-test
bt = AlphaBacktestInstance()
# Public variables are stored in context. We can also store anything in it
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
bt.init_from_config(backtest_props)
bt.run_alpha()
# After finishing back-test, we save trade results into a folder
bt.save_results(folder_path=backtest_result_folder)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myselector', func=my_selector)
signal_model = model.FactorSignalModel()
signal_model.add_signal(name='signalsize', func=signal_size)
strategy = AlphaStrategy(stock_selector=stock_selector,
pc_method='factor_value_weight',
signal_model=signal_model)
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv,
instance=bt,
strategy=strategy,
trade_api=trade_api,
pm=pm)
for mdl in [signal_model, stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"symbol": dv.symbol,
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e7,
"position_ratio": 1.0,
"commission_rate": 2E-4 # 手续费万2
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
signal_model = model.FactorSignalModel()
signal_model.add_signal('stockWeight', stockWeight)
strategy = AlphaStrategy(signal_model=signal_model, pc_method='factor_value_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
signal_model.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "week",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myselector', func=my_selector)
signal_model = model.FactorSignalModel()
signal_model.add_signal(name='signalsize', func=signal_size)
strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='factor_value_weight',
signal_model=signal_model)
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
for mdl in [signal_model, stock_selector]:
mdl.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def alpha_strategy_backtest():
dv = DataView()
dv.load_dataview(folder_path=dataview_folder)
props = {
"benchmark": benchmark,
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
trade_api.init_from_config(props)
stock_selector = model.StockSelector()
stock_selector.add_filter(name='selector_roe_roa_not_new', func=selector_roe_roa_not_new)
strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='equal_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_folder)
def test_backtest_analyze():
ta = ana.AlphaAnalyzer()
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
ta.initialize(dataview=dv, file_folder=backtest_result_dir_path)
print "process trades..."
ta.process_trades()
print "get daily stats..."
ta.get_daily()
print "calc strategy return..."
ta.get_returns(consider_commission=True)
# position change info is huge!
# print "get position change..."
# ta.get_pos_change_info()
selected_sec = list(ta.universe)[:2]
if len(selected_sec) > 0:
print "Plot single securities PnL"
for symbol in selected_sec:
df_daily = ta.daily.get(symbol, None)
if df_daily is not None:
ana.plot_trades(df_daily,
symbol=symbol,
save_folder=backtest_result_dir_path)
print "Plot strategy PnL..."
ta.plot_pnl(backtest_result_dir_path)
print "generate report..."
static_folder = jutil.join_relative_path("trade/analyze/static")
ta.gen_report(source_dir=static_folder,
template_fn='report_template.html',
out_folder=backtest_result_dir_path,
selected=selected_sec)
ta.brinson('sw1')
def do_backtest():
# Load local data file that we just stored.
dv = DataView()
dv.load_dataview(folder_path=dataview_store_folder)
backtest_props = {# start and end date of back-test
"start_date": dv.start_date,
"end_date": dv.end_date,
# re-balance period length
"period": "month",
# benchmark and universe
"benchmark": dv.benchmark,
"universe": dv.universe,
# Amount of money at the start of back-test
"init_balance": 1e8,
# Amount of money at the start of back-test
"position_ratio": 1.0,
}
backtest_props.update(data_config)
backtest_props.update(trade_config)
# We use trade_api to send orders
trade_api = AlphaTradeApi()
# This is our strategy
strategy = AlphaStrategy(pc_method='market_value_weight')
# PortfolioManager helps us to manage tasks, orders and calculate positions
pm = PortfolioManager()
# BacktestInstance is in charge of running the back-test
bt = AlphaBacktestInstance()
# Public variables are stored in context. We can also store anything in it
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
bt.init_from_config(backtest_props)
bt.run_alpha()
# After finishing back-test, we save trade results into a folder
bt.save_results(folder_path=backtest_result_folder)
def test_alpha_strategy_dataview():
dv = DataView()
dv.load_dataview(folder_path=dataview_dir_path)
props = {
"benchmark": "000300.SH",
"universe": ','.join(dv.symbol),
"start_date": dv.start_date,
"end_date": dv.end_date,
"period": "month",
"days_delay": 0,
"init_balance": 1e8,
"position_ratio": 1.0,
}
props.update(data_config)
props.update(trade_config)
trade_api = AlphaTradeApi()
stock_selector = model.StockSelector()
stock_selector.add_filter(name='myrank', func=my_selector)
strategy = AlphaStrategy(stock_selector=stock_selector, pc_method='equal_weight')
pm = PortfolioManager()
bt = AlphaBacktestInstance()
context = model.Context(dataview=dv, instance=bt, strategy=strategy, trade_api=trade_api, pm=pm)
stock_selector.register_context(context)
bt.init_from_config(props)
bt.run_alpha()
bt.save_results(folder_path=backtest_result_dir_path)
def test_analyze_signal():
# --------------------------------------------------------------------------------
# Step.1 load dataview
dv = DataView()
dv.load_dataview(dataview_folder)
# --------------------------------------------------------------------------------
# Step.2 calculate mask (to mask those ill data points)
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status == u'停牌'
df_index_member = dv.get_ts('index_member')
mask_index_member = ~(df_index_member > 0)
dv.add_formula('limit_reached', 'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095', is_quarterly=False)
df_limit_reached = dv.get_ts('limit_reached')
mask_limit_reached = df_limit_reached > 0
mask_all = np.logical_or(mask_sus, np.logical_or(mask_index_member, mask_limit_reached))
# --------------------------------------------------------------------------------
# Step.3 get signal, benchmark and price data
dv.add_formula('divert', '- Correlation(vwap_adj, volume, 10)', is_quarterly=False)
signal = dv.get_ts('divert').shift(1, axis=0) # avoid look-ahead bias
price = dv.get_ts('close_adj')
price_bench = dv.data_benchmark
# Step.4 analyze!
my_period = 5
obj = SignalDigger(output_folder='../output/test_signal', output_format='pdf')
obj.process_signal_before_analysis(signal, price=price,
mask=mask_all,
n_quantiles=5, period=my_period,
benchmark_price=price_bench,
)
res = obj.create_full_report()
def test_q_get():
dv = DataView()
dv.load_dataview(folder_path=quarterly_path)
res = dv.get("", 0, 0, 'total_oper_rev')
assert set(res.index.values) == set(dv.dates[dv.dates >= dv.start_date])
