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 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_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 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_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 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_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_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 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 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])