趋势变化敏感速度数值, 重构所有因子的index方式，简化上层使用

abupy/AlphaBu/ABuPickTimeWorker.py

@@ -98,11 +98,11 @@ def _day_task(self, today):
  # 注意回测模式下始终非高频，非当日买菜，不区分美股，A股市场，卖出因子要先于买入因子的执行
  for sell_factor in self.sell_factors:
  # 迭代卖出因子，每个卖出因子针对今日交易数据，已经所以交易单进行择时
- sell_factor.fit_day(today, self.orders)
+ sell_factor.read_fit_day(today, self.orders)
  # 买入因子行为要在卖出因子下面，否则为高频日交易模式
  for buy_factor in self.buy_factors:
  # 迭代买入因子，每个因子都对今天进行择时，如果生成order加入self.orders
- order = buy_factor.fit_day(today)
+ order = buy_factor.read_fit_day(today)
  if order and order.order_deal:
  self.orders.append(order)
 

abupy/CoreBu/ABuPdHelper.py

@@ -23,7 +23,6 @@
  g_pandas_has_resampler = True
 except ImportError:
  try:
- # 整天瞎鸡巴移代码位置，里面一行也没改
  # noinspection PyUnresolvedReferences
  from pandas.core.resample import DatetimeIndexResampler
  g_pandas_has_resampler = True

abupy/FactorBuyBu/ABuFactorBuyBase.py

@@ -107,6 +107,9 @@ def __init__(self, capital, kl_pd, combine_kl_pd, benchmark, **kwargs):
  # 默认的factor_name，子类通过_init_self可覆盖更具体的名字
  self.factor_name = '{}'.format(self.__class__.__name__)
 
+ # 忽略的交易日数量
+ self.skip_days = 0
+
  # 子类继续完成自有的构造
  self._init_self(**kwargs)
 
@@ -118,13 +121,15 @@ def __str__(self):
 
  __repr__ = __str__
 
- def make_buy_order(self, day_ind):
+ def make_buy_order(self, day_ind=-1):
  """
  根据交易发生的时间索引，依次进行交易订单生成，交易时间序列特征生成，
  决策交易是否拦截，生成特征学习数据，最终返回order，即订单生效
  :param day_ind: 交易发生的时间索引，即对应self.kl_pd.key
- :return:
  """
+ if day_ind == -1:
+ # 默认模式下非高频，信号发出后，明天进行买入操作
+ day_ind = self.today_ind
 
  order = AbuOrder()
  # AbuOrde对象根据交易发生的时间索引生成交易订单
@@ -169,8 +174,43 @@ def _init_self(self, **kwargs):
  """子类因子针对可扩展参数的初始化"""
  pass
 
+ def read_fit_day(self, today):
+ """
+ 在择时worker对象中做日交易的函数，亦可以理解为盘前的一些决策事件处理，
+ 内部会调用子类实现的fit_day函数
+ :param today: 当前驱动的交易日金融时间序列数据
+ :return: 生成的交易订单AbuOrder对象
+ """
+ if self.skip_days > 0:
+ self.skip_days -= 1
+ return None
+
+ # 今天这个交易日在整个金融时间序列的序号
+ self.today_ind = int(today.key)
+ # 回测中默认忽略最后一个交易日
+ if self.today_ind >= self.kl_pd.shape[0] - 1:
+ return None
+
+ return self.fit_day(today)
+
+ def buy_tomorrow(self):
+ """
+ 明天进行买入操作，比如突破策略使用了今天收盘的价格做为参数，发出了买入信号，
+ 需要进行明天买入操作，不能执行今天买入操作
+ :return 生成的交易订单AbuOrder对象
+ """
+ return self.make_buy_order(self.today_ind)
+
+ def buy_today(self):
+ """
+ 今天即进行买入操作，需要不能使用今天的收盘数据等做为fit_day中信号判断，
+ 适合如比特币非明确一天交易日时间或者特殊情况的买入信号
+ :return 生成的交易订单AbuOrder对象
+ """
+ return self.make_buy_order(self.today_ind - 1)
+
  @abstractmethod
- def fit_day(self, *args, **kwargs):
+ def fit_day(self, today):
  """子类主要需要实现的函数，完成策略因子针对每一个交易日的买入交易策略"""
  pass
 

abupy/FactorBuyBu/ABuFactorBuyBreak.py

@@ -21,8 +21,6 @@ def _init_self(self, **kwargs):
  """kwargs中必须包含: 突破参数xd 比如20，30，40天...突破"""
  # 突破参数 xd， 比如20，30，40天...突破, 不要使用kwargs.pop('xd', 20), 明确需要参数xq
  self.xd = kwargs['xd']
- # 忽略连续创新高，比如买入后第二天又突破新高，忽略
- self.skip_days = 0
  # 在输出生成的orders_pd中显示的名字
  self.factor_name = '{}:{}'.format(self.__class__.__name__, self.xd)
 
@@ -32,25 +30,16 @@ def fit_day(self, today):
  :param today: 当前驱动的交易日金融时间序列数据
  :return:
  """
-
- # key是金融时间序列索引
- day_ind = int(today.key)
- # 忽略不符合买入的天（统计周期内前xd天及最后一天）
- if day_ind < self.xd - 1 or day_ind >= self.kl_pd.shape[0] - 1:
- return None
-
- # TODO: 如果子策略中使用skip_days频率高，加个装饰器，子类依据情况选择是否装饰
- if self.skip_days > 0:
- # 执行买入订单后的忽略，否则如果昨天突破了执行了买入，今天继续又比昨天高，难道继续买入吗
- self.skip_days -= 1
+ # 忽略不符合买入的天（统计周期内前xd天）
+ if self.today_ind < self.xd - 1:
  return None
 
  # 今天的收盘价格达到xd天内最高价格则符合买入条件
- if today.close == self.kl_pd.close[day_ind - self.xd + 1:day_ind + 1].max():
+ if today.close == self.kl_pd.close[self.today_ind - self.xd + 1:self.today_ind + 1].max():
  # 把突破新高参数赋值skip_days，这里也可以考虑make_buy_order确定是否买单成立，但是如果停盘太长时间等也不好
  self.skip_days = self.xd
- # 生成买入订单
- return self.make_buy_order(day_ind)
+ # 生成买入订单, 由于使用了今天的收盘价格做为策略信号判断，所以信号发出后，只能明天买
+ return self.buy_tomorrow()
  return None
 
 
@@ -63,7 +52,6 @@ def _init_self(self, **kwargs):
 
  # 突破参数 xd， 比如20，30，40天...突破, 不要使用kwargs.pop('xd', 20), 明确需要参数xq
  self.xd = kwargs['xd']
- self.skip_days = 0
  self.factor_name = '{}:{}'.format(self.__class__.__name__, self.xd)
 
  def fit_day(self, today):
@@ -72,19 +60,13 @@ def fit_day(self, today):
  :param today: 当前驱动的交易日金融时间序列数据
  :return:
  """
- day_ind = int(today.key)
- # 忽略不符合买入的天（统计周期内前xd天及最后一天）
- if day_ind < self.xd - 1 or day_ind >= self.kl_pd.shape[0] - 1:
+ # 忽略不符合买入的天（统计周期内前xd天）
+ if self.today_ind < self.xd - 1:
  return None
- if self.skip_days > 0:
- # 执行买入订单后的忽略
- self.skip_days -= 1
- return None
-
  """
  与AbuFactorBuyBreak区别就是买向下突破的，即min()
  """
- if today.close == self.kl_pd.close[day_ind - self.xd + 1:day_ind + 1].min():
+ if today.close == self.kl_pd.close[self.today_ind - self.xd + 1:self.today_ind + 1].min():
  self.skip_days = self.xd
- return self.make_buy_order(day_ind)
+ return self.buy_tomorrow()
  return None

abupy/FactorBuyBu/ABuFactorBuyDemo.py

@@ -31,7 +31,6 @@ def _init_self(self, **kwargs):
 
  # 下面的代码和AbuFactorBuyBase的实现一摸一样
  self.xd = kwargs['xd']
- self.skip_days = 0
  self.factor_name = '{}:{}'.format(self.__class__.__name__, self.xd)
 
  def fit_month(self, today):
@@ -46,7 +45,7 @@ def fit_month(self, today):
  end_key = int(benchmark_today.ix[0].key)
  start_key = end_key - 20
  if start_key < 0:
- return 0
+ return False
 
  # 使用切片切出从今天开始向前20天的数据
  benchmark_month = benchmark_df[start_key:end_key + 1]
@@ -68,15 +67,14 @@ def fit_day(self, today):
  return None
 
  # 下面的代码和AbuFactorBuyBase的实现一摸一样
- day_ind = int(today.key)
- if day_ind < self.xd - 1 or day_ind >= self.kl_pd.shape[0] - 1:
- return None
- if self.skip_days > 0:
- self.skip_days -= 1
+ if self.today_ind < self.xd - 1:
  return None
- if today.close == self.kl_pd.close[day_ind - self.xd + 1:day_ind + 1].max():
+ # 今天的收盘价格达到xd天内最高价格则符合买入条件
+ if today.close == self.kl_pd.close[self.today_ind - self.xd + 1:self.today_ind + 1].max():
+ # 把突破新高参数赋值skip_days，这里也可以考虑make_buy_order确定是否买单成立，但是如果停盘太长时间等也不好
  self.skip_days = self.xd
- return self.make_buy_order(day_ind)
+ # 生成买入订单, 由于使用了今天的收盘价格做为策略信号判断，所以信号发出后，只能明天买
+ return self.buy_tomorrow()
  return None
 
 
@@ -94,20 +92,18 @@ def fit_day(self, today):
  :param today: 当前驱动的交易日金融时间序列数据
  :return:
  """
- # key是金融时间序列索引
- day_ind = int(today.key)
- # 忽略不符合买入的天（统计周期内前第1天及最后一天）
- if day_ind == 0 or day_ind >= self.kl_pd.shape[0] - 1:
+ # 忽略不符合买入的天（统计周期内前第1天, 因为要用到昨天的交易数据）
+ if self.today_ind == 0:
  return None
 
  # 今天的涨幅
  td_change = today.p_change
  # 昨天的涨幅
- yd_change = self.kl_pd.ix[day_ind - 1].p_change
+ yd_change = self.kl_pd.ix[self.today_ind - 1].p_change
 
  if td_change > 0 and 0 < yd_change < td_change:
- # 连续涨两天, 且今天的涨幅比昨天还高 －>买入
- return self.make_buy_order(day_ind)
+ # 连续涨两天, 且今天的涨幅比昨天还高 －>买入, 用到了今天的涨幅，只能明天买
+ return self.buy_tomorrow()
  return None
 
 
@@ -178,11 +174,8 @@ def _init_self(self, **kwargs):
  """
  # 突破参数 xd， 比如20，30，40天...突破, 不要使用kwargs.pop('xd', 20), 明确需要参数xq
  self.xd = kwargs['xd']
- # 忽略连续创新高，比如买入后第二天又突破新高，忽略
- self.skip_days = 0
  # 在输出生成的orders_pd中显示的名字
  self.factor_name = '{}:{}'.format(self.__class__.__name__, self.xd)
-
  # 添加了通过AbuFactorBuyBreakUmpDemo记录训练好的决策器
  self.hit_ml = kwargs['hit_ml']
 
@@ -248,14 +241,12 @@ def fit_day(self, today):
  """
  self.pg.show()
 
- # key是金融时间序列索引
- day_ind = int(today.key)
- # 忽略不符合买入的天（统计周期内前两天及最后一天），因为btc的机器学习特证需要三天交易数据
- if day_ind < 2 or day_ind >= self.kl_pd.shape[0] - 1:
+ # 忽略不符合买入的天（统计周期内前两天, 因为btc的机器学习特证需要三天交易数据）
+ if self.today_ind < 2:
  return None
 
  # 今天，昨天，前天三天的交易数据进行特证转换
- btc = self.kl_pd[day_ind - 2:day_ind + 1]
+ btc = self.kl_pd[self.today_ind - 2:self.today_ind + 1]
  # 三天的交易数据进行转换后得到btc_today_x
  btc_today_x = self.make_btc_today(btc)
 
@@ -265,7 +256,8 @@ def fit_day(self, today):
  # 买入条件1: 当日这100个股票60%以上都是上涨的
  vote_val = self.similar_predict(today.date)
  if vote_val > self.btc_vote_val:
- return self.make_buy_order(day_ind - 1)
+ # 没有使用当天交易日的close等数据，且btc_ml判断的大波动是当日，所以当日买入
+ return self.buy_today()
 
  # noinspection PyUnresolvedReferences
  def make_btc_today(self, sib_btc):

abupy/FactorBuyBu/ABuFactorBuyGolden.py

@@ -32,11 +32,8 @@ def _init_self(self, **kwargs):
  self.ma_day = kwargs.pop('ma_day', 5)
  # 短暂停留阀值stay_day(int)，默认进入1天即算
  self.stay_day = kwargs.pop('stay_day', 1)
-
- self.skip_days = 0
  # 交易目标短暂停留的标志
  self.below_stay_days = 0
-
  # 在输出生成的orders_pd中显示的名字
  self.factor_name = '{}:{}'.format(self.__class__.__name__, self.xd)
 
@@ -46,19 +43,12 @@ def fit_day(self, today):
  :param today: 当前驱动的交易日金融时间序列数据
  :return:
  """
- # key是金融时间序列索引
- day_ind = int(today.key)
- # 忽略不符合买入的天（统计周期内前xd天及最后一天）
- if day_ind < self.xd - 1 or day_ind >= self.kl_pd.shape[0] - 1:
- return None
-
- if self.skip_days > 0:
- # 执行买入订单后的忽略
- self.skip_days -= 1
+ # 忽略不符合买入的天（统计周期内前xd天）
+ if self.today_ind < self.xd - 1:
  return None
 
  # 切片从前xd开始直到当前交易日为止的金融序列数据
- window_pd = self.kl_pd[day_ind - self.xd + 1: day_ind + 1]
+ window_pd = self.kl_pd[self.today_ind - self.xd + 1: self.today_ind + 1]
  # 在切片的金融序列数据上计算黄金分割档位值，具体阅读ABuTLGolden.calc_golden
  golden = ABuTLGolden.calc_golden(window_pd, show=False)
 
@@ -99,6 +89,6 @@ def ma_break_func():
  self.below_stay_days = 0
  # 放弃一段时间的买入观察, 放弃周期＝self.xd/2
  self.skip_days = self.xd / 2
- # 生成买单
- return self.make_buy_order(day_ind)
+ # 生成买单, 由于使用了今天的收盘价格做为策略信号判断，所以信号发出后，只能明天买
+ return self.buy_tomorrow()
  return None

abupy/FactorSellBu/ABuFactorAtrNStop.py

@@ -7,7 +7,7 @@
 from __future__ import print_function
 from __future__ import division
 
-from .ABuFactorSellBase import AbuFactorSellBase, filter_sell_order, skip_last_day, ESupportDirection
+from .ABuFactorSellBase import AbuFactorSellBase, ESupportDirection
 
 __author__ = '阿布'
 __weixin__ = 'abu_quant'
@@ -38,8 +38,6 @@ def support_direction(self):
  """n倍atr(止盈止损)因子支持两个方向"""
  return [ESupportDirection.DIRECTION_CAll.value, ESupportDirection.DIRECTION_PUT.value]
 
- @skip_last_day
- @filter_sell_order
  def fit_day(self, today, orders):
  """
  止盈event：截止今天相比买入时的收益 * 买入时的期望方向 > n倍atr
@@ -60,9 +58,12 @@ def fit_day(self, today, orders):
  if hasattr(self, 'stop_win_n') and profit > 0 and profit > self.stop_win_n * stop_base:
  # 满足止盈条件卖出股票, 即收益(profit) > n倍atr
  self.sell_type_extra = self.sell_type_extra_win
- order.fit_sell_order(int(today.key), self)
+ # 由于使用了当天的close价格，所以明天才能卖出
+ self.sell_tomorrow(order)
 
  if hasattr(self, 'stop_loss_n') and profit < 0 and profit < -self.stop_loss_n * stop_base:
  # 满足止损条件卖出股票, 即收益(profit) < -n倍atr
  self.sell_type_extra = self.sell_type_extra_loss
- order.fit_sell_order(int(today.key), self)
+ order.fit_sell_order(self.today_ind, self)
+ # 由于使用了当天的close价格，所以明天才能卖出
+ self.sell_tomorrow(order)

abupy/FactorSellBu/ABuFactorCloseAtrNStop.py

@@ -8,7 +8,7 @@
 from __future__ import print_function
 from __future__ import division
 
-from .ABuFactorSellBase import AbuFactorSellBase, filter_sell_order, skip_last_day, ESupportDirection
+from .ABuFactorSellBase import AbuFactorSellBase, ESupportDirection
 
 __author__ = '阿布'
 __weixin__ = 'abu_quant'
@@ -34,8 +34,6 @@ def support_direction(self):
  """单日最大跌幅n倍atr(止损)因子支持两个方向"""
  return [ESupportDirection.DIRECTION_CAll.value, ESupportDirection.DIRECTION_PUT.value]
 
- @skip_last_day
- @filter_sell_order
  def fit_day(self, today, orders):
  """
  止盈event： 较小利润值 < 买入后最大收益价格 - 今日价格 < 较大利润值
@@ -44,13 +42,11 @@ def fit_day(self, today, orders):
  :return:
  """
 
- # 今天即当前交易日在金融时间序列中的index
- day_ind = int(today.key)
  for order in orders:
  # 通过order中的买入日期计算金融时间序列kl_pd中的index
  mask_date = self.kl_pd['date'] == order.buy_date
  start_ind = int(self.kl_pd[mask_date]['key'].values)
- end_ind = day_ind + 1
+ end_ind = self.today_ind + 1
 
  """
  从买入日子开始计算到今天得到买入后最大收盘价格作为max_close，
@@ -65,4 +61,5 @@ def fit_day(self, today, orders):
  """
  if (max_close - order.buy_price) * order.expect_direction > today['atr21'] \
  and (max_close - today.close) * order.expect_direction > today['atr21'] * self.close_atr_n:
- order.fit_sell_order(day_ind, self)
+ # 由于使用了当天的close价格，所以明天才能卖出
+ self.sell_tomorrow(order)