def test_dataview_universe():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date':
20170227,
'end_date':
20170327,
'universe':
'000016.SH',
# 'symbol': 'rb1710.SHF,rb1801.SHF',
'fields':
('open,high,low,close,vwap,volume,turnover,' + 'sw1,zz2,' +
'roe,net_assets,' + 'total_oper_rev,oper_exp,tot_profit,int_income'),
'freq':
1
}
dv.init_from_config(props, ds)
dv.prepare_data()
data_bench = dv.data_benchmark.copy()
dv.data_benchmark = data_bench
try:
dv.data_benchmark = data_bench.iloc[3:]
except ValueError:
pass
dv.remove_field('roe,net_assets')
dv.remove_field('close')
def test_save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {'start_date': 20150101, 'end_date': 20170930, 'universe': '000905.SH',
'fields': ('tot_cur_assets,tot_cur_liab,inventories,pre_pay,deferred_exp,'
'eps_basic,ebit,pe,pb,float_mv,sw1'),
'freq': 1}
dv.init_from_config(props, ds)
dv.prepare_data()
factor_formula = 'pe < 30'
dv.add_formula('pe_condition', factor_formula, is_quarterly=False)
factor_formula = 'pb < 3'
dv.add_formula('pb_condition', factor_formula, is_quarterly=False)
factor_formula = 'Return(eps_basic, 4) > 0'
dv.add_formula('eps_condition', factor_formula, is_quarterly=True)
factor_formula = 'Return(ebit, 4) > 0'
dv.add_formula('ebit_condition', factor_formula, is_quarterly=True)
factor_formula = 'tot_cur_assets/tot_cur_liab > 2'
dv.add_formula('current_condition', factor_formula, is_quarterly=True)
factor_formula = '(tot_cur_assets - inventories - pre_pay - deferred_exp)/tot_cur_liab > 1'
dv.add_formula('quick_condition', factor_formula, is_quarterly=True)
dv.add_formula('mv_rank', 'Rank(float_mv)', is_quarterly=False)
dv.save_dataview(folder_path=dataview_dir_path)
def get_dv(start = 20170101,end = 20180101):
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
import warnings
warnings.filterwarnings("ignore")
#--------------------------------------------------------
#define
factor_list = [ 'alpha190', 'alpha96', 'DebtEquityRatio', 'NetAssetGrowRate',
'SharpeRatio120', 'RC12' ,'InformationRatio20']
check_factor = ','.join(factor_list)
dataview_folder = r'../data'
ds = LocalDataService(fp = dataview_folder)
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {'start_date': start, 'end_date': end, 'symbol':','.join(stock_symbol),
'fields': check_factor,
'freq': 1,
"prepare_fields": True}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
return dv
def test_save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date': 20170101,
'end_date': 20171001,
'universe': '000300.SH',
'fields': ('float_mv,pb,pe_ttm,sw2'),
'freq': 1
}
dv.init_from_config(props, ds)
dv.prepare_data()
factor_formula = 'GroupQuantile(-float_mv, sw2, 10)'
dv.add_formula('rank_mv', factor_formula, is_quarterly=False)
factor_formula = 'GroupQuantile(If(pb >= 0.2, pb, 100), sw2, 10)'
dv.add_formula('rank_pb', factor_formula, is_quarterly=False)
factor_formula = 'GroupQuantile(If(pe_ttm >= 3, pe_ttm, 9999.0), sw2, 10)'
dv.add_formula('rank_pe', factor_formula, is_quarterly=False)
dv.save_dataview(folder_path=dataview_dir_path)
def get_dv(start=20170101, end=20180101):
import warnings
warnings.filterwarnings("ignore")
try:
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
except ImportError as e:
_handle_import_exception(e)
ds = LocalDataService(fp=get_data_root())
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {
'start_date': start,
'end_date': end,
'symbol': ','.join(stock_symbol),
'fields': "",
'freq': 1,
"prepare_fields": True
}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
hs300_benchmark = dv.data_api.daily("000300.SH",
dv.extended_start_date_d,
dv.end_date,
fields='trade_date,close')
dv.data_benchmark = hs300_benchmark[0][['trade_date',
'close']].set_index('trade_date')
return dv
def test_write():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
secs = '600030.SH,000063.SZ,000001.SZ'
props = {
'start_date': 20160601,
'end_date': 20170601,
'symbol': secs,
'fields': 'open,close,high,low,volume,pb,net_assets,pcf_ncf',
'freq': 1
}
dv.init_from_config(props, data_api=ds)
dv.prepare_data()
assert dv.data_d.shape == (281, 48)
assert dv.dates.shape == (281, )
# TODO
"""
PerformanceWarning:
your performance may suffer as PyTables will pickle object types that it cannot
map directly to c-types [inferred_type->mixed,key->block1_values] [items->[('000001.SZ', 'int_income'), ('000001.SZ', 'less_handling_chrg_comm_exp'), ('000001.SZ', 'net_int_income'), ('000001.SZ', 'oper_exp'), ('000001.SZ', 'symbol'), ('000063.SZ', 'int_income'), ('000063.SZ', 'less_handling_chrg_comm_exp'), ('000063.SZ', 'net_int_income'), ('000063.SZ', 'oper_exp'), ('000063.SZ', 'symbol'), ('600030.SH', 'int_income'), ('600030.SH', 'less_handling_chrg_comm_exp'), ('600030.SH', 'net_int_income'), ('600030.SH', 'oper_exp'), ('600030.SH', 'symbol')]]
"""
dv.save_dataview(folder_path=daily_path)
def save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date': 20150101,
'end_date': 20170930,
'universe': '000905.SH',
'fields': ('turnover,float_mv,close_adj,pe,pb'),
'freq': 1
}
dv.init_from_config(props, ds)
dv.prepare_data()
factor_formula = 'Cutoff(Standardize(turnover / 10000 / float_mv), 2)'
dv.add_formula('TO', factor_formula, is_quarterly=False)
factor_formula = 'Cutoff(Standardize(1/pb), 2)'
dv.add_formula('BP', factor_formula, is_quarterly=False)
factor_formula = 'Cutoff(Standardize(Return(close_adj, 20)), 2)'
dv.add_formula('REVS20', factor_formula, is_quarterly=False)
factor_formula = 'Cutoff(Standardize(Log(float_mv)), 2)'
dv.add_formula('float_mv_factor', factor_formula, is_quarterly=False)
factor_formula = 'Delay(Return(close_adj, 1), -1)'
dv.add_formula('NextRet', factor_formula, is_quarterly=False)
dv.save_dataview(folder_path=dataview_dir_path)
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 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 get_dv(start=20170101, end=20180101):
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
import warnings
warnings.filterwarnings("ignore")
#--------------------------------------------------------
#define
factor_list = ['PB', 'turnover_ratio', 'volume', 'pe_ttm']
check_factor = ','.join(factor_list)
dataview_folder = r'E:\BaiduNetdiskDownload\data\data'
ds = LocalDataService(fp=dataview_folder)
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {
'start_date': start,
'end_date': end,
'symbol': ','.join(stock_symbol),
'fields': check_factor,
'freq': 1,
"prepare_fields": True
}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
return dv
def save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date': 20150101,
'end_date': 20171001,
'universe': '000300.SH',
'fields': 'volume,turnover,float_mv,pb,total_mv',
'freq': 1
}
dv.init_from_config(props, ds)
dv.prepare_data()
# for convenience to check limit reachers
dv.add_formula('limit_reached',
'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095',
is_quarterly=False)
dv.add_formula('random', 'StdDev(volume, 20)', is_quarterly=False)
dv.add_formula('momentum', 'Return(close_adj, 20)', is_quarterly=False)
# dv.add_formula('size', '', is_quarterly=False)
dv.save_dataview(dataview_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 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 save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date': 20150101,
'end_date': 20171001,
'universe': '000300.SH',
'fields': 'volume,turnover,float_mv,pb,total_mv',
'freq': 1
}
dv.init_from_config(props, ds)
dv.prepare_data()
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status == '停牌'
dv.append_df(mask_sus, 'suspended', is_quarterly=False)
dv.add_formula('not_index_member', '!index_member', is_quarterly=False)
dv.add_formula('limit_reached',
'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095',
is_quarterly=False)
dv.save_dataview(dataview_folder)
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 get_dv(start = 20170101,end = 20180101):
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
import warnings
warnings.filterwarnings("ignore")
#--------------------------------------------------------
#define
factor_list = ['TSEPToTotalCapital','alpha107','TRIX5_J','OperatingRevenueGrowRate_J','LossVariance60','BIAS60_J','alpha110','DIZ_J']
check_factor = ','.join(factor_list)
dataview_folder = r'E:/data/data'
ds = LocalDataService(fp = dataview_folder)
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {'start_date': start, 'end_date': end, 'symbol':','.join(stock_symbol),
'fields': check_factor,
'freq': 1,
"prepare_fields": True}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
return dv
def save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date': 20160101,
'end_date': 20171001,
'universe': '000300.SH',
'fields': 'volume,turnover',
'freq': 1
}
dv.init_from_config(props, ds)
dv.prepare_data()
# for convenience to check limit reachers
dv.add_formula('limit_reached',
'Abs((open - Delay(close, 1)) / Delay(close, 1)) > 0.095',
is_quarterly=False)
dv.add_formula('mask_limit_reached',
'limit_reached > 0',
is_quarterly=False)
dv.add_formula('mask_index_member',
'!(index_member > 0)',
is_quarterly=False)
trade_status = dv.get_ts('trade_status')
mask_sus = trade_status == u'停牌'
dv.append_df(mask_sus, 'mask_sus', is_quarterly=False)
# dv.add_formula('size', '', is_quarterly=False)
dv.save_dataview(dataview_folder)
def get_dv(start = 20170101,end = 20180101):
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
import warnings
warnings.filterwarnings("ignore")
#--------------------------------------------------------
#define
factor_list = ['BBI', 'net_profit', 'tot_shrhldr_eqy_excl_min_int'
# ,'EPS','PE','PS','ACCA','CTOP','MA10RegressCoeff12','AR','BR','ARBR','np_parent_comp_ttm','total_share','bps'
]
check_factor = ','.join(factor_list)
dataview_folder = r'../data'
ds = LocalDataService(fp=dataview_folder)
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {'start_date': start, 'end_date': end, 'symbol':','.join(stock_symbol),
'fields': check_factor,
'freq': 1,
"prepare_fields": True}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
return dv
def get_dv(start=20170101, end=20180101):
import jaqs_fxdayu
jaqs_fxdayu.patch_all()
from jaqs.data import DataView
from jaqs_fxdayu.data.dataservice import LocalDataService
import warnings
warnings.filterwarnings("ignore")
factor_list = [
'alpha60', 'alpha61', 'SRMI', 'OperatingProfitGrowRate',
'InterestCover_J', 'ROECut', 'StaticPE_J', 'VOL60'
]
check_factor = ','.join(factor_list)
dataview_folder = r'../data'
ds = LocalDataService(fp=dataview_folder)
ZZ800_id = ds.query_index_member("000906.SH", start, end)
stock_symbol = list(set(ZZ800_id))
dv_props = {
'start_date': start,
'end_date': end,
'symbol': ','.join(stock_symbol),
'fields': check_factor,
'freq': 1,
"prepare_fields": True
}
dv = DataView()
dv.init_from_config(dv_props, data_api=ds)
dv.prepare_data()
return dv
def save_dataview():
ds = RemoteDataService()
ds.init_from_config(data_config)
dv = DataView()
props = {
'start_date':
20170101,
'end_date':
20171030,
'universe':
'000300.SH',
'fields': (
'open,high,low,close,vwap,volume,turnover,sw1,'
# + 'pb,net_assets,'
+ 'eps_basic,total_mv,tot_profit,int_income'),
'freq':
1
}
dv.init_from_config(props, ds)
dv.prepare_data()
factor_formula = 'close >= Delay(Ts_Max(close, 20), 1)' # 20 days new high
factor_name = 'new_high'
dv.add_formula(factor_name, factor_formula, is_quarterly=False)
dv.add_formula('total_profit_growth',
formula='Return(tot_profit, 4)',
is_quarterly=True)
dv.save_dataview(folder_path=dataview_dir_path)
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 save_data():
"""
This function fetches data from remote server and stores them locally.
Then we can use local data to do back-test.
"""
dataview_props = {
'start_date': 20170101, # Start and end date of back-test
'end_date': 20171030,
'universe': UNIVERSE, # Investment universe and performance benchmark
'benchmark': '000300.SH',
'fields': 'total_mv,turnover', # Data fields that we need
'freq':
1 # freq = 1 means we use daily data. Please do not change this.
}
# RemoteDataService communicates with a remote server to fetch data
ds = RemoteDataService()
# Use username and password in data_config to login
ds.init_from_config(data_config)
# DataView utilizes RemoteDataService to get various data and store them
dv = DataView()
dv.init_from_config(dataview_props, ds)
dv.prepare_data()
dv.save_dataview(folder_path=dataview_store_folder)
def save_data():
"""
This function fetches data from remote server and stores them locally.
Then we can use local data to do back-test.
"""
dataview_props = {'start_date': 20170101, # Start and end date of back-test
'end_date': 20171030,
'universe': UNIVERSE, # Investment universe and performance benchmark
'benchmark': '000905.SH',
'fields': 'high,low,close', # Data fields that we need
'freq': 1 # freq = 1 means we use daily data. Please do not change this.
}
# RemoteDataService communicates with a remote server to fetch data
ds = RemoteDataService()
# Use username and password in data_config to login
ds.init_from_config(data_config)
# DataView utilizes RemoteDataService to get various data and store them
dv = DataView()
dv.init_from_config(dataview_props, ds)
dv.prepare_data()
# 以9日为周期的KD线为例。首先须计算出最近9日的RSV值,即未成熟随机值,
# 计算公式为
# 9日RSV=(C-L9)÷(H9-L9)×100
# 式中,C为第9日的收盘价;L9为9日内的最低价;H9为9日内的最高价。
# K值=2/3×前一日K值+1/3×当日RSV
# D值=2/3×前一日K值+1/3×当日RSV
# J指标的计算公式为: J=3D—2K
factor_formula = '2/3*50 + (close-Ts_Min(low，5))/(Ts_Max(high，5)-Ts_Min(low，5)*100)'
dv.add_formula()
dv.save_dataview(folder_path=dataview_store_folder)
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 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_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])
