def sample_935_2():
"""
9.3.5_2 不同权重的评分: 只考虑胜率
:return:
"""
from abupy import ABuFileUtil
score_fn = '../gen/score_tuple_array'
if not ABuFileUtil.file_exist(score_fn):
print(
'../gen/score_tuple_array not exist! please execute sample_933 first!'
)
return
"""
直接读取本地序列化文件
"""
score_tuple_array = ABuFileUtil.load_pickle(score_fn)
from abupy import WrsmScorer
# 只有第一项为1，其他都是0代表只考虑胜率来评分
scorer = WrsmScorer(score_tuple_array, weights=[1, 0, 0, 0])
# 返回按照评分排序后的队列
scorer_returns_max = scorer.fit_score()
# index[-1]为最优参数序号
best_score_tuple_grid = score_tuple_array[scorer_returns_max.index[-1]]
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd,
best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital,
best_score_tuple_grid.benchmark,
only_info=False)
# 最后打印出只考虑胜率下最优结果使用的买入策略和卖出策略
print(
'best_score_tuple_grid.buy_factors, best_score_tuple_grid.sell_factors:\n',
best_score_tuple_grid.buy_factors, best_score_tuple_grid.sell_factors)
def sample_933():
"""
9.3.3 GridSearch寻找最优参数
:return:
"""
from abupy import GridSearch
read_cash = 1000000
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
sell_factors_product, buy_factors_product = sample_932(show=False)
grid_search = GridSearch(read_cash, choice_symbols,
buy_factors_product=buy_factors_product,
sell_factors_product=sell_factors_product)
from abupy import ABuFileUtil
"""
注意下面的运行耗时大约1小时多，如果所有cpu都用上的话，也可以设置n_jobs为 < cpu进程数，一边做其它的一边跑
"""
# 运行GridSearch n_jobs=-1启动cpu个数的进程数
scores, score_tuple_array = grid_search.fit(n_jobs=-1)
"""
针对运行完成输出的score_tuple_array可以使用dump_pickle保存在本地，以方便修改其它验证效果。
"""
ABuFileUtil.dump_pickle(score_tuple_array, '../gen/score_tuple_array')
print('组合因子参数数量{}'.format(len(buy_factors_product) * len(sell_factors_product)))
print('最终评分结果数量{}'.format(len(scores)))
best_score_tuple_grid = grid_search.best_score_tuple_grid
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd, best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital, best_score_tuple_grid.benchmark)
def sample_935_2():
"""
9.3.5_2 不同权重的评分: 只考虑胜率
:return:
"""
from abupy import ABuFileUtil
score_fn = '../gen/score_tuple_array'
if not ABuFileUtil.file_exist(score_fn):
print('../gen/score_tuple_array not exist! please execute sample_933 first!')
return
"""
直接读取本地序列化文件
"""
score_tuple_array = ABuFileUtil.load_pickle(score_fn)
from abupy import WrsmScorer
# 只有第一项为1，其他都是0代表只考虑胜率来评分
scorer = WrsmScorer(score_tuple_array, weights=[1, 0, 0, 0])
# 返回按照评分排序后的队列
scorer_returns_max = scorer.fit_score()
# index[-1]为最优参数序号
best_score_tuple_grid = score_tuple_array[scorer_returns_max.index[-1]]
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd,
best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital,
best_score_tuple_grid.benchmark,
only_info=False)
# 最后打印出只考虑胜率下最优结果使用的买入策略和卖出策略
print('best_score_tuple_grid.buy_factors, best_score_tuple_grid.sell_factors:\n', best_score_tuple_grid.buy_factors,
best_score_tuple_grid.sell_factors)
def sample_933():
"""
9.3.3 GridSearch寻找最优参数
:return:
"""
from abupy import GridSearch
read_cash = 1000000
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
sell_factors_product, buy_factors_product = sample_932(show=False)
grid_search = GridSearch(read_cash, choice_symbols,
buy_factors_product=buy_factors_product,
sell_factors_product=sell_factors_product)
from abupy import ABuFileUtil
"""
注意下面的运行耗时大约1小时多，如果所有cpu都用上的话，也可以设置n_jobs为 < cpu进程数，一边做其它的一边跑
"""
# 运行GridSearch n_jobs=-1启动cpu个数的进程数
scores, score_tuple_array = grid_search.fit(n_jobs=-1)
"""
针对运行完成输出的score_tuple_array可以使用dump_pickle保存在本地，以方便修改其它验证效果。
"""
ABuFileUtil.dump_pickle(score_tuple_array, '../gen/score_tuple_array')
print('组合因子参数数量{}'.format(len(buy_factors_product) * len(sell_factors_product)))
print('最终评分结果数量{}'.format(len(scores)))
best_score_tuple_grid = grid_search.best_score_tuple_grid
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd, best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital, best_score_tuple_grid.benchmark)
def sample_935_1():
"""
9.3.5_1 不同权重的评分: 只考虑投资回报来评分
:return:
"""
from abupy import ABuFileUtil
score_fn = '../gen/score_tuple_array'
if not ABuFileUtil.file_exist(score_fn):
print('../gen/score_tuple_array not exist! please execute sample_933 first!')
return
"""
直接读取本地序列化文件
"""
score_tuple_array = ABuFileUtil.load_pickle(score_fn)
from abupy import WrsmScorer
# 实例化WrsmScorer，参数weights，只有第二项为1，其他都是0，
# 代表只考虑投资回报来评分
scorer = WrsmScorer(score_tuple_array, weights=[0, 1, 0, 0])
# 返回排序后的队列
scorer_returns_max = scorer.fit_score()
# 因为是倒序排序，所以index最后一个为最优参数
best_score_tuple_grid = score_tuple_array[scorer_returns_max.index[-1]]
# 由于篇幅，最优结果只打印文字信息
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd,
best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital,
best_score_tuple_grid.benchmark,
only_info=True)
# 最后打印出只考虑投资回报下最优结果使用的买入策略和卖出策略
print('best_score_tuple_grid.buy_factors, best_score_tuple_grid.sell_factors:\n', best_score_tuple_grid.buy_factors,
best_score_tuple_grid.sell_factors)
def sample_935_1():
"""
9.3.5_1 不同权重的评分: 只考虑投资回报来评分
:return:
"""
from abupy import ABuFileUtil
score_fn = '../gen/score_tuple_array'
if not ABuFileUtil.file_exist(score_fn):
print('../gen/score_tuple_array not exist! please execute sample_933 first!')
return
"""
直接读取本地序列化文件
"""
score_tuple_array = ABuFileUtil.load_pickle(score_fn)
from abupy import WrsmScorer
# 实例化WrsmScorer，参数weights，只有第二项为1，其他都是0，
# 代表只考虑投资回报来评分
scorer = WrsmScorer(score_tuple_array, weights=[0, 1, 0, 0])
# 返回排序后的队列
scorer_returns_max = scorer.fit_score()
# 因为是倒序排序，所以index最后一个为最优参数
best_score_tuple_grid = score_tuple_array[scorer_returns_max.index[-1]]
# 由于篇幅，最优结果只打印文字信息
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd,
best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital,
best_score_tuple_grid.benchmark,
only_info=True)
# 最后打印出只考虑投资回报下最优结果使用的买入策略和卖出策略
print('best_score_tuple_grid.buy_factors, best_score_tuple_grid.sell_factors:\n', best_score_tuple_grid.buy_factors,
best_score_tuple_grid.sell_factors)
def run_loo_back(choice_symbols, start, end):
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
start=start,
end=end,
choice_symbols=choice_symbols,
n_process_pick=1)
ABuProgress.clear_output()
AbuMetricsBase.show_general(*abu_result_tuple,
returns_cmp=True,
only_info=True)
return abu_result_tuple
def run_loo_back(choice_symbols,
ps=None,
n_folds=3,
start=None,
end=None,
only_info=False):
"""封装一个回测函数，返回回测结果，以及回测度量对象"""
if choice_symbols[0].startswith('us'):
abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_US
else:
abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_CN
abu_result_tuple, _ = abu.run_loop_back(cash,
buy_factors,
sell_factors,
ps,
start=start,
end=end,
n_folds=n_folds,
choice_symbols=choice_symbols)
ABuProgress.clear_output()
metrics = AbuMetricsBase.show_general(*abu_result_tuple,
returns_cmp=only_info,
only_info=only_info,
only_show_returns=True)
return abu_result_tuple, metrics
def sample_94_2(from_cache=False):
"""
9.4_2 使用切割训练集测试集模式，且生成交易特征，回测训练集交易数据, mac pro顶配大概下面跑了4个小时
:return:
"""
# 关闭沙盒数据环境
abupy.env.disable_example_env_ipython()
from abupy import EMarketDataFetchMode
# 因为sample_94_1下载了预先数据，使用缓存，设置E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
# 回测将symbols切割分为训练集数据和测试集数据
abupy.env.g_enable_train_test_split = True
# 下面设置回测时切割训练集，测试集使用的切割比例参数，默认为10，即切割为10份，9份做为训练，1份做为测试，
# 由于美股股票数量多，所以切割分为4份，3份做为训练集，1份做为测试集
abupy.env.g_split_tt_n_folds = 4
from abupy import EStoreAbu
if from_cache:
abu_result_tuple = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
else:
# 初始化资金200万，资金管理依然使用默认atr
read_cash = 5000000
# 每笔交易的买入基数资金设置为万分之15
abupy.beta.atr.g_atr_pos_base = 0.0015
# 使用run_loop_back运行策略，因子使用和之前一样，
# choice_symbols=None为全市场回测，5年历史数据回测
# 不同电脑运行速度差异大，mac pro顶配大概下面跑了4小时
# choice_symbols=None为全市场回测，5年历史数据回测
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors, sell_factors,
stock_pickers,
choice_symbols=None,
start='2012-08-08', end='2017-08-08')
# 把运行的结果保存在本地，以便之后分析回测使用，保存回测结果数据代码如下所示
abu.store_abu_result_tuple(abu_result_tuple, n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
print('abu_result_tuple.action_pd.deal.value_counts():\n', abu_result_tuple.action_pd.deal.value_counts())
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
def sample_a21():
# 设置初始资金数
read_cash = 500000000
# 择时股票池
# choice_symbols = ['603993', '601998', '601992', '601991', '601989', '601988', '601985', '601939', '601933', '601919', '601901', '601899', '601898', '601881', '601877', '601857', '601828', '601818', '601808', '601800', '601788', '601766', '601727', '601688', '601669', '601668', '601633', '601628', '601618', '601607', '601601', '601600', '601398', '601390', '601360', '601328', '601288', '601238', '601229', '601225', '601211', '601186', '601169', '601166', '601155', '601111', '601108', '601088', '601018', '601012', '601009', '601006', '600999', '600958', '600919', '600900', '600893', '600887', '600837', '600816', '600795', '600703', '600690', '600688', '600663', '600660', '600606', '600600', '600588', '600585', '600518', '600487', '600406', '600398', '600383', '600362', '600346', '600340', '600309', '600297', '600221', '600196', '600188', '600176', '600115', '600111', '600104', '600061', '600050', '600048', '600036', '600031', '600030', '600029', '600028', '600025', '600023', '600019', '600018', '600016', '600015', '600011', '600010', '600000', '300498', '300433', '300124', '300072', '300070', '300059', '300015', '300003', '002739', '002736', '002714', '002600', '002558', '002493', '002475', '002456', '002450', '002415', '002310', '002252', '002241', '002236', '002202', '002142', '002120', '002044', '002027', '002024', '002010', '001979', '001965', '000895', '000776', '000725', '000617', '000166', '000069', '000063', '000039', '000002', '000001']
# choice_symbols = ['601398']
choice_symbols = None
# choice_symbols = ['600999']
# choice_symbols = ['601398', '601988', '601939', '603993', '600999', '300059', '600900', '601328', '601288', '600887', '600029', '000002']
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=1,
commission_dict=commission_dict)
print(abu_result_tuple.orders_pd)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
# plot_simple = abu_result_tuple.orders_pd[abu_result_tuple.orders_pd.profit_cg < 0]
# save=True保存在本地，耗时操作，需要运行几分钟
# ABuMarketDrawing.plot_candle_from_order(plot_simple, save=False)
# 筛出有交易结果的
orders_pd_atr = abu_result_tuple.orders_pd[
abu_result_tuple.orders_pd.result != 0]
orders_pd_atr.filter(
['buy_cnt', 'buy_pos', 'buy_price', 'profit', 'result'])
metrics.plot_returns_cmp(only_info=True)
# 保存交易结果
store_abu_result_out_put(abu_result_tuple)
metrics.plot_order_returns_cmp()
# metrics.plot_buy_factors()
# metrics.plot_sell_factors()
# metrics.plot_effect_mean_day()
# plt.show()
# metrics.plot_keep_days()
# plt.show()
metrics.plot_max_draw_down()
def sample_91(show=True):
"""
9.1 度量的基本使用方法
:return:
"""
# 设置初始资金数
read_cash = 1000000
# 择时股票池
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usTSLA', 'usWUBA', 'usVIPS']
# 使用run_loop_back运行策略
abu_result_tuple, kl_pd_manager = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols, n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
if show:
metrics.plot_returns_cmp()
return metrics
def sample_94_4(from_cache=False):
"""
满仓乘数
9.4_4 《量化交易之路》中通过把初始资金扩大到非常大，但是每笔交易的买入基数却不增高，来使交易全部都成交，
再使用满仓乘数的示例，由于需要再次进行全市场回测，比较耗时。
下面直接示例通过AbuMetricsBase中的transform_to_full_rate_factor接口将之前的回测结果转换为使用大初始资金回测的结果
:return:
"""
metrics_test = sample_94_3(from_cache=True, show=False)
from abupy import EStoreAbu
if from_cache:
test_us_fr = abu.load_abu_result_tuple(
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us_full_rate')
# 本地读取后使用AbuMetricsBase构造度量对象，参数enable_stocks_full_rate_factor=True, 即使用满仓乘数
test_frm = AbuMetricsBase(test_us_fr.orders_pd,
test_us_fr.action_pd,
test_us_fr.capital,
test_us_fr.benchmark,
enable_stocks_full_rate_factor=True)
test_frm.fit_metrics()
else:
test_frm = metrics_test.transform_to_full_rate_factor(n_process_kl=4,
show=False)
# 转换后保存起来，下次直接读取，不用再转换了
from abupy import AbuResultTuple
test_us_fr = AbuResultTuple(test_frm.orders_pd, test_frm.action_pd,
test_frm.capital, test_frm.benchmark)
abu.store_abu_result_tuple(test_us_fr,
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us_full_rate')
"""
使用test_frm进行度量结果可以看到所有交易都顺利成交了，策略买入成交比例:100.0000%，但资金利用率显然过低，
它导致基准收益曲线和策略收益曲线不在一个量级上，无法有效的进行对比
"""
AbuMetricsBase.show_general(test_frm.orders_pd,
test_frm.action_pd,
test_frm.capital,
test_frm.benchmark,
only_show_returns=True)
"""转换出来的test_frm即是一个使用满仓乘数的度量对象，下面使用test_frm直接进行满仓度量即可"""
print(type(test_frm))
test_frm.plot_returns_cmp(only_show_returns=True)
# 如果不需要与基准进行对比，最简单的方式是使用plot_order_returns_cmp
metrics_test.plot_order_returns_cmp()
def sample_94_3(from_cache=False, show=True):
"""
9.4_3 使用切割好的测试数据集快，mac pro顶配大概下面跑了半个小时
:return:
"""
# 关闭沙盒数据环境
abupy.env.disable_example_env_ipython()
from abupy import EMarketDataFetchMode
# 因为sample_94_1下载了预先数据，使用缓存，设置E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_enable_train_test_split = False
# 使用切割好的测试数据
abupy.env.g_enable_last_split_test = True
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
from abupy import EStoreAbu
if from_cache:
abu_result_tuple_test = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
else:
read_cash = 5000000
abupy.beta.atr.g_atr_pos_base = 0.007
choice_symbols = None
abu_result_tuple_test, kl_pd_manager_test = abu.run_loop_back(read_cash,
buy_factors, sell_factors, stock_pickers,
choice_symbols=choice_symbols, start='2012-08-08',
end='2017-08-08')
abu.store_abu_result_tuple(abu_result_tuple_test, n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
print('abu_result_tuple_test.action_pd.deal.value_counts():\n', abu_result_tuple_test.action_pd.deal.value_counts())
metrics = AbuMetricsBase(*abu_result_tuple_test)
metrics.fit_metrics()
if show:
metrics.plot_returns_cmp(only_show_returns=True)
return metrics
def sample_91(show=True):
"""
9.1 度量的基本使用方法
:return:
"""
# 设置初始资金数
read_cash = 1000000
# 择时股票池
choice_symbols = [
'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA',
'usVIPS'
]
# 使用run_loop_back运行策略
abu_result_tuple, kl_pd_manager = abu.run_loop_back(
read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
if show:
metrics.plot_returns_cmp()
return metrics
def sample_814(show=True):
"""
8.1.4 对多支股票进行择时
:return:
"""
sell_factor1 = {'xd': 120, 'class': AbuFactorSellBreak}
sell_factor2 = {'stop_loss_n': 0.5, 'stop_win_n': 3.0, 'class': AbuFactorAtrNStop}
sell_factor3 = {'class': AbuFactorPreAtrNStop, 'pre_atr_n': 1.0}
sell_factor4 = {'class': AbuFactorCloseAtrNStop, 'close_atr_n': 1.5}
sell_factors = [sell_factor1, sell_factor2, sell_factor3, sell_factor4]
benchmark = AbuBenchmark()
buy_factors = [{'xd': 60, 'class': AbuFactorBuyBreak},
{'xd': 42, 'class': AbuFactorBuyBreak}]
choice_symbols = ['usTSLA', 'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usWUBA', 'usVIPS']
capital = AbuCapital(1000000, benchmark)
orders_pd, action_pd, all_fit_symbols_cnt = ABuPickTimeExecute.do_symbols_with_same_factors(choice_symbols,
benchmark, buy_factors,
sell_factors, capital,
show=False)
metrics = AbuMetricsBase(orders_pd, action_pd, capital, benchmark)
metrics.fit_metrics()
if show:
print('orders_pd[:10]:\n', orders_pd[:10].filter(
['symbol', 'buy_price', 'buy_cnt', 'buy_factor', 'buy_pos', 'sell_date', 'sell_type_extra', 'sell_type',
'profit']))
print('action_pd[:10]:\n', action_pd[:10])
metrics.plot_returns_cmp(only_show_returns=True)
return metrics
def sample_817():
"""
8.1.7 使用并行来提升择时运行效率
:return:
"""
# 要关闭沙盒数据环境，因为沙盒里就那几个股票的历史数据, 下面要随机做50个股票
from abupy import EMarketSourceType
abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_tx
abupy.env.disable_example_env_ipython()
# 关闭沙盒后，首先基准要从非沙盒环境换取，否则数据对不齐，无法正常运行
benchmark = AbuBenchmark()
# 当传入choice_symbols为None时代表对整个市场的所有股票进行回测
# noinspection PyUnusedLocal
choice_symbols = None
# 顺序获取市场后300支股票
# noinspection PyUnusedLocal
choice_symbols = ABuMarket.all_symbol()[-50:]
# 随机获取300支股票
choice_symbols = ABuMarket.choice_symbols(50)
capital = AbuCapital(1000000, benchmark)
sell_factor1 = {'xd': 120, 'class': AbuFactorSellBreak}
sell_factor2 = {'stop_loss_n': 0.5, 'stop_win_n': 3.0, 'class': AbuFactorAtrNStop}
sell_factor3 = {'class': AbuFactorPreAtrNStop, 'pre_atr_n': 1.0}
sell_factor4 = {'class': AbuFactorCloseAtrNStop, 'close_atr_n': 1.5}
sell_factors = [sell_factor1, sell_factor2, sell_factor3, sell_factor4]
buy_factors = [{'xd': 60, 'class': AbuFactorBuyBreak},
{'xd': 42, 'class': AbuFactorBuyBreak}]
orders_pd, action_pd, _ = AbuPickTimeMaster.do_symbols_with_same_factors_process(
choice_symbols, benchmark, buy_factors, sell_factors,
capital)
metrics = AbuMetricsBase(orders_pd, action_pd, capital, benchmark)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
abupy.env.enable_example_env_ipython()
def load_abu_result_tuple():
abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_CN
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
abu_result_tuple_train = abu.load_abu_result_tuple(
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_cn')
abu_result_tuple_test = abu.load_abu_result_tuple(
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_cn')
metrics_train = AbuMetricsBase(*abu_result_tuple_train)
metrics_train.fit_metrics()
metrics_test = AbuMetricsBase(*abu_result_tuple_test)
metrics_test.fit_metrics()
return abu_result_tuple_train, abu_result_tuple_test, metrics_train, metrics_test
def load_abu_result_tuple():
abu_result_tuple_train = abu.load_abu_result_tuple(
n_folds=6,
store_type=abupy.EStoreAbu.E_STORE_CUSTOM_NAME,
# custom_name='tt_train_cn')
custom_name='18_6_top_train_cn')
abu_result_tuple_test = abu.load_abu_result_tuple(
n_folds=6,
store_type=abupy.EStoreAbu.E_STORE_CUSTOM_NAME,
# custom_name='tt_test_cn')
custom_name='18_6_top_test_cn')
metrics_train = AbuMetricsBase(*abu_result_tuple_train)
metrics_train.fit_metrics()
metrics_test = AbuMetricsBase(*abu_result_tuple_test)
metrics_test.fit_metrics()
return abu_result_tuple_train, abu_result_tuple_test, metrics_train, metrics_test
def sample_94_2(from_cache=False):
"""
9.4_2 使用切割训练集测试集模式，且生成交易特征，回测训练集交易数据, mac pro顶配大概下面跑了4个小时
:return:
"""
# 关闭沙盒数据环境
abupy.env.disable_example_env_ipython()
from abupy import EMarketDataFetchMode
# 因为sample_94_1下载了预先数据，使用缓存，设置E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
# 回测将symbols切割分为训练集数据和测试集数据
abupy.env.g_enable_train_test_split = True
# 下面设置回测时切割训练集，测试集使用的切割比例参数，默认为10，即切割为10份，9份做为训练，1份做为测试，
# 由于美股股票数量多，所以切割分为4份，3份做为训练集，1份做为测试集
abupy.env.g_split_tt_n_folds = 4
from abupy import EStoreAbu
if from_cache:
abu_result_tuple = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
else:
# 初始化资金200万，资金管理依然使用默认atr
read_cash = 5000000
# 每笔交易的买入基数资金设置为万分之15
abupy.beta.atr.g_atr_pos_base = 0.0015
# 使用run_loop_back运行策略，因子使用和之前一样，
# choice_symbols=None为全市场回测，5年历史数据回测
# 不同电脑运行速度差异大，mac pro顶配大概下面跑了4小时
# choice_symbols=None为全市场回测，5年历史数据回测
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=None,
start='2012-08-08',
end='2017-08-08')
# 把运行的结果保存在本地，以便之后分析回测使用，保存回测结果数据代码如下所示
abu.store_abu_result_tuple(abu_result_tuple,
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
print('abu_result_tuple.action_pd.deal.value_counts():\n',
abu_result_tuple.action_pd.deal.value_counts())
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
def load_abu_result_tuple():
abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_CN
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
abu_result_tuple_train = abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_cn')
abu_result_tuple_test = abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_cn')
metrics_train = AbuMetricsBase(*abu_result_tuple_train)
metrics_train.fit_metrics()
metrics_test = AbuMetricsBase(*abu_result_tuple_test)
metrics_test.fit_metrics()
return abu_result_tuple_train, abu_result_tuple_test, metrics_train, metrics_test
def sample_817():
"""
8.1.7 使用并行来提升择时运行效率
:return:
"""
# 要关闭沙盒数据环境，因为沙盒里就那几个股票的历史数据, 下面要随机做50个股票
from abupy import EMarketSourceType
abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_tx
abupy.env.disable_example_env_ipython()
# 关闭沙盒后，首先基准要从非沙盒环境换取，否则数据对不齐，无法正常运行
benchmark = AbuBenchmark()
# 当传入choice_symbols为None时代表对整个市场的所有股票进行回测
# noinspection PyUnusedLocal
choice_symbols = None
# 顺序获取市场后300支股票
# noinspection PyUnusedLocal
choice_symbols = ABuMarket.all_symbol()[-50:]
# 随机获取300支股票
choice_symbols = ABuMarket.choice_symbols(50)
capital = AbuCapital(1000000, benchmark)
sell_factor1 = {'xd': 120, 'class': AbuFactorSellBreak}
sell_factor2 = {
'stop_loss_n': 0.5,
'stop_win_n': 3.0,
'class': AbuFactorAtrNStop
}
sell_factor3 = {'class': AbuFactorPreAtrNStop, 'pre_atr_n': 1.0}
sell_factor4 = {'class': AbuFactorCloseAtrNStop, 'close_atr_n': 1.5}
sell_factors = [sell_factor1, sell_factor2, sell_factor3, sell_factor4]
buy_factors = [{
'xd': 60,
'class': AbuFactorBuyBreak
}, {
'xd': 42,
'class': AbuFactorBuyBreak
}]
orders_pd, action_pd, _ = AbuPickTimeMaster.do_symbols_with_same_factors_process(
choice_symbols, benchmark, buy_factors, sell_factors, capital)
metrics = AbuMetricsBase(orders_pd, action_pd, capital, benchmark)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
abupy.env.enable_example_env_ipython()
def sample_94_3(from_cache=False, show=True):
"""
9.4_3 使用切割好的测试数据集快，mac pro顶配大概下面跑了半个小时
:return:
"""
# 关闭沙盒数据环境
abupy.env.disable_example_env_ipython()
from abupy import EMarketDataFetchMode
# 因为sample_94_1下载了预先数据，使用缓存，设置E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
abupy.env.g_enable_train_test_split = False
# 使用切割好的测试数据
abupy.env.g_enable_last_split_test = True
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
from abupy import EStoreAbu
if from_cache:
abu_result_tuple_test = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
else:
read_cash = 5000000
abupy.beta.atr.g_atr_pos_base = 0.007
choice_symbols = None
abu_result_tuple_test, kl_pd_manager_test = abu.run_loop_back(
read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
start='2012-08-08',
end='2017-08-08')
abu.store_abu_result_tuple(abu_result_tuple_test,
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
print('abu_result_tuple_test.action_pd.deal.value_counts():\n',
abu_result_tuple_test.action_pd.deal.value_counts())
metrics = AbuMetricsBase(*abu_result_tuple_test)
metrics.fit_metrics()
if show:
metrics.plot_returns_cmp(only_show_returns=True)
return metrics
def run_loo_back(choice_symbols,
ps=None,
n_folds=3,
start=None,
end=None,
only_info=False):
abu_result_tuple, _ = abu.run_loop_back(cash,
buy_factors,
sell_factors,
ps,
start=start,
end=end,
n_folds=n_folds,
choice_symbols=choice_symbols)
abu_result_tuple.orders_pd['buy_factor'] = abu_result_tuple.orders_pd[
'buy_factor'].apply(lambda bf: bf.split(':')[0])
ABuProgress.clear_output()
metrics = AbuMetricsBase.show_general(*abu_result_tuple,
returns_cmp=only_info,
only_info=only_info,
only_show_returns=True)
return abu_result_tuple, metrics
def sample_94_4(from_cache=False):
"""
满仓乘数
9.4_4 《量化交易之路》中通过把初始资金扩大到非常大，但是每笔交易的买入基数却不增高，来使交易全部都成交，
再使用满仓乘数的示例，由于需要再次进行全市场回测，比较耗时。
下面直接示例通过AbuMetricsBase中的transform_to_full_rate_factor接口将之前的回测结果转换为使用大初始资金回测的结果
:return:
"""
metrics_test = sample_94_3(from_cache=True, show=False)
from abupy import EStoreAbu
if from_cache:
test_us_fr = abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us_full_rate')
# 本地读取后使用AbuMetricsBase构造度量对象，参数enable_stocks_full_rate_factor=True, 即使用满仓乘数
test_frm = AbuMetricsBase(test_us_fr.orders_pd, test_us_fr.action_pd, test_us_fr.capital, test_us_fr.benchmark,
enable_stocks_full_rate_factor=True)
test_frm.fit_metrics()
else:
test_frm = metrics_test.transform_to_full_rate_factor(n_process_kl=4, show=False)
# 转换后保存起来，下次直接读取，不用再转换了
from abupy import AbuResultTuple
test_us_fr = AbuResultTuple(test_frm.orders_pd, test_frm.action_pd, test_frm.capital, test_frm.benchmark)
abu.store_abu_result_tuple(test_us_fr, n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us_full_rate')
"""
使用test_frm进行度量结果可以看到所有交易都顺利成交了，策略买入成交比例:100.0000%，但资金利用率显然过低，
它导致基准收益曲线和策略收益曲线不在一个量级上，无法有效的进行对比
"""
AbuMetricsBase.show_general(test_frm.orders_pd,
test_frm.action_pd, test_frm.capital, test_frm.benchmark, only_show_returns=True)
"""转换出来的test_frm即是一个使用满仓乘数的度量对象，下面使用test_frm直接进行满仓度量即可"""
print(type(test_frm))
test_frm.plot_returns_cmp(only_show_returns=True)
# 如果不需要与基准进行对比，最简单的方式是使用plot_order_returns_cmp
metrics_test.plot_order_returns_cmp()
def sample_a21():
"""
A.2.1 数据模式的切换
:return:
"""
# 表A-1所示
print(ABuSymbolPd.make_kl_df('601398').tail())
# 局部使用enable_example_env_ipython，示例
# abupy.env.enable_example_env_ipython()
# 如果本地有相应股票的缓存，可以使用如下代码强制使用本地缓存数据
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
# 设置初始资金数
read_cash = 1000000
# # 择时股票池
# choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA', 'usVIPS']
# # 使用run_loop_back运行策略
# abu_result_tuple, _ = abu.run_loop_back(read_cash,
# buy_factors, sell_factors, stock_pickers, choice_symbols=choice_symbols,
# n_folds=2)
# metrics = AbuMetricsBase(*abu_result_tuple)
# metrics.fit_metrics()
# metrics.plot_returns_cmp()
# *****************************************************************************************************************
# 切换数据源
abupy.env.g_market_source = EMarketSourceType.E_MARKET_SOURCE_bd
# 强制走网络数据源
# abupy.env.g_data_cache_type = EMarketDataFetchMode.E_DATA_CACHE_HDF5
# 择时股票池
# choice_symbols = ['601398', '600028', '601857', '601318', '600036', '000002', '600050', '600030']
choice_symbols = ['601398']
# 使用run_loop_back运行策略
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors, sell_factors, stock_pickers, choice_symbols=choice_symbols,
n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
def sample_a22():
# 设置初始资金数
read_cash = 5000000
abupy.env.g_enable_ump_main_deg_block = True
abupy.env.g_enable_ump_main_jump_block = True
abupy.env.g_enable_ump_main_price_block = True
abupy.env.g_enable_ump_main_wave_block = True
# 择时股票池
# choice_symbols = ['603993', '601998', '601992', '601991', '601989', '601988', '601985', '601939', '601933', '601919', '601901', '601899', '601898', '601881', '601877', '601857', '601828', '601818', '601808', '601800', '601788', '601766', '601727', '601688', '601669', '601668', '601633', '601628', '601618', '601607', '601601', '601600', '601398', '601390', '601360', '601328', '601288', '601238', '601229', '601225', '601211', '601186', '601169', '601166', '601155', '601111', '601108', '601088', '601018', '601012', '601009', '601006', '600999', '600958', '600919', '600900', '600893', '600887', '600837', '600816', '600795', '600703', '600690', '600688', '600663', '600660', '600606', '600600', '600588', '600585', '600518', '600487', '600406', '600398', '600383', '600362', '600346', '600340', '600309', '600297', '600221', '600196', '600188', '600176', '600115', '600111', '600104', '600061', '600050', '600048', '600036', '600031', '600030', '600029', '600028', '600025', '600023', '600019', '600018', '600016', '600015', '600011', '600010', '600000', '300498', '300433', '300124', '300072', '300070', '300059', '300015', '300003', '002739', '002736', '002714', '002600', '002558', '002493', '002475', '002456', '002450', '002415', '002310', '002252', '002241', '002236', '002202', '002142', '002120', '002044', '002027', '002024', '002010', '001979', '001965', '000895', '000776', '000725', '000617', '000166', '000069', '000063', '000039', '000002', '000001']
choice_symbols = ['601398']
# choice_symbols = ['600036']
# choice_symbols = ['601398', '601988', '601939', '601328', '601288', '600887', '600029', '000002']
# choice_symbols = ['601398', '601988', '601939', '603993', '600999', '300059', '600900', '601328', '601288',
# '600887', '600029', '000002', '600196', '002024', '002241', '600050', '601989', '601992', '601901']
choice_symbols = ['601398', '601988', '601939', '603993', '600196', '600660', '600703', '600887', '600999', '300059', '600900', '601328', '601288', '600887', '600029', '000002']
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors, sell_factors, stock_pickers, choice_symbols=choice_symbols,
n_folds=7, commission_dict=commission_dict)
# AbuMetricsBase.show_general(*abu_result_tuple, only_show_returns=True)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
# 筛出有交易结果的
orders_pd_atr = abu_result_tuple.orders_pd[abu_result_tuple.orders_pd.result != 0]
orders_pd_atr.filter(['buy_cnt', 'buy_pos', 'buy_price', 'profit', 'result'])
# 保存交易结果
store_abu_result_out_put(abu_result_tuple)
metrics.plot_returns_cmp(only_info=True)
# metrics.plot_buy_factors()
# metrics.plot_sell_factors()
metrics.plot_effect_mean_day()
# plt.show()
metrics.plot_keep_days()
# plt.show()
metrics.plot_max_draw_down()
def load_score_cache():
"""有本地数据score_tuple_array后，即可以从本地缓存读取score_tuple_array"""
global scores, score_tuple_array
with AbuBlockProgress('load score cache'):
score_tuple_array = ABuFileUtil.load_pickle('../gen/score_tuple_array')
if not hasattr(grid_search, 'best_score_tuple_grid'):
# load_pickle的grid_search没有赋予best_score_tuple_grid，这里补上
from abupy import make_scorer, WrsmScorer
scores = make_scorer(score_tuple_array, WrsmScorer)
grid_search.best_score_tuple_grid = score_tuple_array[
scores.index[-1]]
print('load complete!')
def select(select):
if select == 'run gird search':
run_grid_search()
else: # load score cache
load_score_cache()
_ = ipywidgets.interact_manual(select,
select=['run gird search', 'load score cache'])
best_score_tuple_grid = grid_search.best_score_tuple_grid
AbuMetricsBase.show_general(best_score_tuple_grid.orders_pd,
best_score_tuple_grid.action_pd,
best_score_tuple_grid.capital,
best_score_tuple_grid.benchmark)
from abupy import AbuFactorBuyBreak
from abupy import AbuFactorAtrNStop
from abupy import AbuFactorPreAtrNStop
from abupy import AbuFactorCloseAtrNStop
from abupy import abu
from abupy import AbuMetricsBase
if __name__ == '__main__':
# 初始资金
read_cash = 10000
# 选股因子，这里选择不用
stock_pickers = None
# 买入因子，选用趋势突破中的向上突破
buy_factors = [{'xd': 60, 'class': AbuFactorBuyBreak}, {'xd': 42, 'class': AbuFactorBuyBreak}]
# 卖出因子，选择止盈止损，防暴跌，防盈利后亏损这三种因子
sell_factors = [{'stop_loss_n': 1.0, 'stop_win_n': 3.0, 'class': AbuFactorAtrNStop},
{'class': AbuFactorPreAtrNStop, 'pre_atr_n': 1.5},
{'class': AbuFactorCloseAtrNStop, 'close_atr_n': 1.5}]
# 股票池
# choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA', 'usVIPS']
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU']
# 运行策略
abu_result_tuple, kp_pd_manager = abu.run_loop_back(read_cash, buy_factors, sell_factors, stock_pickers,
choice_symbols=choice_symbols, n_folds=2)
# 对结果进行度量，打印度量结果
metrics=AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
print(abu_result_tuple.head())
# candidates
from abupy import abu
read_cash = 1000000
choice_symbols = [
'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA',
'usVIPS'
]
abu_result_tuple, kl_pd_manager = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols,
n_folds=2)
# 2) 评价回测结果
from abupy import AbuMetricsBase
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
metrics.plot_sharp_volatility_cmp()
# 3) add position control
win_rate = metrics.win_rate
gains_mean = metrics.gains_mean
losses_mean = -metrics.losses_mean
# n天向上突破买入策略(加入买入价格策略,加入仓位控制策略)
buy_factors = [{
'xd': 60,
'class': AbuFactorBuyBreak,
'slippage': AbuSlippageBuyMean,
'win_rate': win_rate,
'gains_mean': gains_mean,
'losses_mean': losses_mean,
#卖出因子
sell_factors = [{
'stop_loss_n': 1.0,
'stop_win_n': 3.0,
'class': AbuFactorAtrNStop
}, {
'class': AbuFactorPreAtrNStop,
'pre_atr_n': 1.5
}, {
'class': AbuFactorCloseAtrNStop,
'close_atr_n': 1.5
}]
#择时股票池
choice_symbols = [
'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA',
'usVIPS'
]
abu_result_tuple, kl_pd_manger = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols,
n_folds=2)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
# metrics.plot_returns_cmp()
metrics.plot_sharp_volatility_cmp()
metrics.plot_max_draw_down()
# 卖出因子
sell_factors = [{
'stop_loss_n': 1.0,
'stop_win_n': 3.0,
'class': AbuFactorAtrNStop
}, {
'class': AbuFactorPreAtrNStop,
'pre_atr_n': 1.5
}, {
'class': AbuFactorCloseAtrNStop,
'close_atr_n': 1.5
}]
# 择时股票池
choice_symbols = [
'hk03333', 'hk00700', 'hk02333', 'hk01359', 'hk00656', 'hk03888', 'hk02318'
]
# 设置市场类型为港股
abupy.env.g_market_target = EMarketTargetType.E_MARKET_TARGET_HK
abu_result_tuple, kl_pd_manger = \
abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
n_folds=6,choice_symbols=choice_symbols)
ABuProgress.clear_output()
AbuMetricsBase.show_general(*abu_result_tuple, only_show_returns=True)
def sample_1051_1(from_cache=False, show=True):
"""
10.5.1 回测中生成特征，切分训练测试集，成交买单快照: 数据准备
:return:
"""
from abupy import AbuMetricsBase
from abupy import AbuFactorBuyBreak
from abupy import AbuFactorAtrNStop
from abupy import AbuFactorPreAtrNStop
from abupy import AbuFactorCloseAtrNStop
# 关闭沙盒数据环境
abupy.env.disable_example_env_ipython()
from abupy import EMarketDataFetchMode
# 因为sample_94_1下载了预先数据，使用缓存，设置E_DATA_FETCH_FORCE_LOCAL，实际上run_kl_update最后会把设置set到FORCE_LOCAL
abupy.env.g_data_fetch_mode = EMarketDataFetchMode.E_DATA_FETCH_FORCE_LOCAL
# 设置选股因子，None为不使用选股因子
stock_pickers = None
# 买入因子依然延用向上突破因子
buy_factors = [{
'xd': 60,
'class': AbuFactorBuyBreak
}, {
'xd': 42,
'class': AbuFactorBuyBreak
}]
# 卖出因子继续使用上一章使用的因子
sell_factors = [{
'stop_loss_n': 1.0,
'stop_win_n': 3.0,
'class': AbuFactorAtrNStop
}, {
'class': AbuFactorPreAtrNStop,
'pre_atr_n': 1.5
}, {
'class': AbuFactorCloseAtrNStop,
'close_atr_n': 1.5
}]
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
# 回测将symbols切割分为训练集数据和测试集数据
abupy.env.g_enable_train_test_split = True
# 下面设置回测时切割训练集，测试集使用的切割比例参数，默认为10，即切割为10份，9份做为训练，1份做为测试，
# 由于美股股票数量多，所以切割分为4份，3份做为训练集，1份做为测试集
abupy.env.g_split_tt_n_folds = 4
from abupy import EStoreAbu
if from_cache:
abu_result_tuple = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
else:
# 初始化资金500万，资金管理依然使用默认atr
read_cash = 5000000
# 每笔交易的买入基数资金设置为万分之15
abupy.beta.atr.g_atr_pos_base = 0.0015
# 使用run_loop_back运行策略，因子使用和之前一样，
# choice_symbols=None为全市场回测，5年历史数据回测
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=None,
start='2012-08-08',
end='2017-08-08')
# 把运行的结果保存在本地，以便之后分析回测使用，保存回测结果数据代码如下所示
abu.store_abu_result_tuple(abu_result_tuple,
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_us')
if show:
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
"＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊"
abupy.env.g_enable_train_test_split = False
# 使用切割好的测试数据
abupy.env.g_enable_last_split_test = True
from abupy import EStoreAbu
if from_cache:
abu_result_tuple_test = \
abu.load_abu_result_tuple(n_folds=5, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
else:
read_cash = 5000000
abupy.beta.atr.g_atr_pos_base = 0.007
choice_symbols = None
abu_result_tuple_test, kl_pd_manager_test = abu.run_loop_back(
read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
start='2012-08-08',
end='2017-08-08')
abu.store_abu_result_tuple(abu_result_tuple_test,
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_us')
if show:
metrics = AbuMetricsBase(*abu_result_tuple_test)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
print(abu_result_tuple.orders_pd[
abu_result_tuple.orders_pd.result != 0].head())
return abu_result_tuple, abu_result_tuple_test
continue
today_max_data = stock_detail_data[stock_detail_data.price ==
kl_pd_yestaday.close]
con_all = stock_detail_data.shape[0]
con_max = today_max_data.shape[0]
maxRate = (con_max * 100) / con_all
order['maxRate'] = maxRate
order_pd = pd.DataFrame(order).T
if maxRate <= 2:
order_pds = order_pd.append(order_pds)
if order.sell_type == 'win':
order_pds_win = order_pd.append(order_pds_win)
elif order.sell_type == 'loss':
order_pds_loss = order_pd.append(order_pds_loss)
pass
# plt.hist(order_pds_win.maxRate,bins=50,normed = True,alpha=0.5,color='red')
# plt.hist(order_pds_loss.maxRate, bins=50, normed=True, alpha=0.5, color='green')
# plt.show()
print(len(order_pds))
print(len(order_pds_win))
print(len(order_pds_loss))
AbuMetricsBase.show_orders(order_pds,
best_result_tuple.action_pd,
best_result_tuple.capital,
best_result_tuple.benchmark,
only_info=True)
else:
print("没有订单生成！")
from abupy import AbuFactorAtrNStop, AbuFactorPreAtrNStop, AbuFactorCloseAtrNStop, AbuFactorBuyBreak
from abupy import abu, EMarketTargetType, AbuMetricsBase, ABuMarketDrawing, ABuProgress, ABuSymbolPd
from abupy import EMarketTargetType, EDataCacheType, EMarketSourceType, EMarketDataFetchMode, EStoreAbu, AbuUmpMainMul
from abupy import AbuUmpMainDeg, AbuUmpMainJump, AbuUmpMainPrice, AbuUmpMainWave, feature, AbuFeatureDegExtend
from abupy import AbuUmpEdgeDeg, AbuUmpEdgePrice, AbuUmpEdgeWave, AbuUmpEdgeFull, AbuUmpEdgeMul, AbuUmpEegeDegExtend
from abupy import AbuUmpMainDegExtend, ump, Parallel, delayed, AbuMulPidProgress, AbuProgress
if __name__ == '__main__':
abu_result_tuple_train = abu.load_abu_result_tuple(
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='train_cn')
abu_result_tuple_test = abu.load_abu_result_tuple(
n_folds=5,
store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='test_cn')
ABuProgress.clear_output()
print('训练集结果：')
metrics_train = AbuMetricsBase.show_general(*abu_result_tuple_train,
only_show_returns=True)
print('测试集结果：')
metrics_test = AbuMetricsBase.show_general(*abu_result_tuple_test,
only_show_returns=True)
grid_search = GridSearch(read_cash,choice_symbols,buy_factors_product=buy_factors_product,
sell_factors_product=sell_factors_product,n_folds=1,start=startDate, end=endDate)
if __name__ == '__main__': #多线程必须内容，不可删除。
scores,score_tuple_array = grid_search.fit(n_jobs=-1)
store_python_obj(score_tuple_array, 'score_tuple_array'+ABuEnv.date_str, show_log=False)
#-------权重方式开始------
if score_tuple_array != None:
scorer = WrsmScorer(score_tuple_array, weights=[1, 0, 0, 0])
scorer_returns_max = scorer.fit_score()
best_result_tuple = score_tuple_array[scorer_returns_max.index[-1]]
print(best_result_tuple.buy_factors) #打印最优因子
print(best_result_tuple.sell_factors) #打印最优因子
store_abu_result_tuple(best_result_tuple, n_folds=None, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='best_1_0_0_0')
AbuMetricsBase.show_general(best_result_tuple.orders_pd, best_result_tuple.action_pd,
best_result_tuple.capital, best_result_tuple.benchmark, only_info=False)
scorer = WrsmScorer(score_tuple_array, weights=[0, 1, 0, 0])
scorer_returns_max = scorer.fit_score()
best_result_tuple = score_tuple_array[scorer_returns_max.index[-1]]
print(best_result_tuple.buy_factors) # 打印最优因子
print(best_result_tuple.sell_factors) # 打印最优因子
store_abu_result_tuple(best_result_tuple, n_folds=None, store_type=EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='best_0_1_0_0')
AbuMetricsBase.show_general(best_result_tuple.orders_pd, best_result_tuple.action_pd,
best_result_tuple.capital, best_result_tuple.benchmark, only_info=True)
else:
print("没有订单生成！")
end = datetime.datetime.now()
print("程序运行时间：" +str(end - start))
#-------权重方式结束------
'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA',
'usVIPS'
]
# 使用run_loop_back运行策略
abu_result_tuple, kl_pd_manger = abu.run_loop_back(
read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=2)
ABuProgress.clear_output()
help(abu.run_loop_back)
from abupy import AbuMetricsBase
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
metrics.plot_returns_cmp()
metrics.plot_sharp_volatility_cmp()
metrics.plot_effect_mean_day()
metrics.plot_keep_days()
metrics.plot_sell_factors()
metrics.plot_max_draw_down()
from abupy import ABuScalerUtil
class MetricsDemo(AbuMetricsBase):
"""扩展自定义度量类示例"""
def _metrics_extend_stats(self):
"""
子类可扩展的metrics方法，子类在此方法中可定义自己需要度量的值:
def sample_a21():
# 设置初始资金数
read_cash = 50000
###########################################################################################
# 回测生成买入时刻特征
abupy.env.g_enable_ml_feature = True
# 回测将symbols切割分为训练集数据和测试集数据
abupy.env.g_enable_train_test_split = True
# 下面设置回测时切割训练集，测试集使用的切割比例参数，默认为10，即切割为10份，9份做为训练，1份做为测试，
# 由于美股股票数量多，所以切割分为4份，3份做为训练集，1份做为测试集
abupy.env.g_split_tt_n_folds = 4
###########################################################################################
# 择时股票池
# choice_symbols = ['603993', '601998', '601992', '601991', '601989', '601988', '601985', '601939', '601933', '601919', '601901', '601899', '601898', '601881', '601877', '601857', '601828', '601818', '601808', '601800', '601788', '601766', '601727', '601688', '601669', '601668', '601633', '601628', '601618', '601607', '601601', '601600', '601398', '601390', '601360', '601328', '601288', '601238', '601229', '601225', '601211', '601186', '601169', '601166', '601155', '601111', '601108', '601088', '601018', '601012', '601009', '601006', '600999', '600958', '600919', '600900', '600893', '600887', '600837', '600816', '600795', '600703', '600690', '600688', '600663', '600660', '600606', '600600', '600588', '600585', '600518', '600487', '600406', '600398', '600383', '600362', '600346', '600340', '600309', '600297', '600221', '600196', '600188', '600176', '600115', '600111', '600104', '600061', '600050', '600048', '600036', '600031', '600030', '600029', '600028', '600025', '600023', '600019', '600018', '600016', '600015', '600011', '600010', '600000', '300498', '300433', '300124', '300072', '300070', '300059', '300015', '300003', '002739', '002736', '002714', '002600', '002558', '002493', '002475', '002456', '002450', '002415', '002310', '002252', '002241', '002236', '002202', '002142', '002120', '002044', '002027', '002024', '002010', '001979', '001965', '000895', '000776', '000725', '000617', '000166', '000069', '000063', '000039', '000002', '000001']
# choice_symbols = ['601398']
choice_symbols = [
'601398', '601988', '601939', '601328', '601288', '600887', '600029',
'000002'
]
abu_result_tuple, _ = abu.run_loop_back(read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=4,
commission_dict=commission_dict)
# 把运行的结果保存在本地，以便之后分析回测使用，保存回测结果数据代码如下所示
abu.store_abu_result_tuple(abu_result_tuple,
n_folds=4,
store_type=abupy.EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='tt_train_cn')
abu.store_abu_result_tuple(abu_result_tuple,
n_folds=4,
store_type=abupy.EStoreAbu.E_STORE_CUSTOM_NAME,
custom_name='tt_test_cn')
# AbuMetricsBase.show_general(*abu_result_tuple, only_show_returns=True)
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
# 筛出有交易结果的
orders_pd_atr = abu_result_tuple.orders_pd[
abu_result_tuple.orders_pd.result != 0]
orders_pd_atr.filter(
['buy_cnt', 'buy_pos', 'buy_price', 'profit', 'result'])
metrics.plot_returns_cmp(only_info=True)
# metrics.plot_buy_factors()
# metrics.plot_sell_factors()
metrics.plot_effect_mean_day()
# plt.show()
metrics.plot_keep_days()
# plt.show()
metrics.plot_max_draw_down()
# 2) simple way
from abupy import ABuPickTimeExecute
orders_pd, action_pd, _ = ABuPickTimeExecute.do_symbols_with_same_factors(
[
'usTSLA', 'usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG',
'usWUBA', 'usVIPS'
],
benchmark,
buy_factors,
sell_factors,
capital,
show=False)
print(orders_pd[:10])
# 3) metric the profit
from abupy import AbuMetricsBase
metrics = AbuMetricsBase(orders_pd, action_pd, capital, benchmark)
metrics.fit_metrics()
metrics.plot_returns_cmp(only_show_returns=True)
# 4) evaluate win_rate(为了计算胜率)
win_rate = metrics.win_rate
gains_mean = metrics.gains_mean
losses_mean = -metrics.losses_mean
# 5) add position control
# n天向上突破买入策略(加入买入价格策略,加入仓位控制策略)
buy_factors = [{
'xd': 60,
'class': AbuFactorBuyBreak,
'slippage': AbuSlippageBuyMean,
'win_rate': win_rate,
'gains_mean': gains_mean,
'losses_mean': losses_mean,
'stop_win_n': 3.0,
'class': AbuFactorAtrNStop
}, {
'class': AbuFactorPreAtrNStop,
'pre_atr_n': 1.5
}, {
'class': AbuFactorCloseAtrNStop,
'close_atr_n': 1.5
}]
# 股票池
# choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU', 'usAAPL', 'usGOOG', 'usTSLA', 'usWUBA', 'usVIPS']
choice_symbols = ['usNOAH', 'usSFUN', 'usBIDU']
# 运行策略
abu_result_tuple, kp_pd_manager = abu.run_loop_back(
read_cash,
buy_factors,
sell_factors,
stock_pickers,
choice_symbols=choice_symbols,
n_folds=2)
# 对结果进行度量，打印度量结果
metrics = AbuMetricsBase(*abu_result_tuple)
metrics.fit_metrics()
# metrics.plot_returns_cmp()
# 策略和基准之间的波动率和夏普比率关系
metrics.plot_sharp_volatility_cmp()
# 买入因子生效间隔之间的关系
metrics.plot_effect_mean_day()
# 持股天数
metrics.plot_keep_days()
plt.show()
