def generate_trade_decision(self, execute_result=None): # generate_trade_decision # generate_target_weight_position() and generate_order_list_from_target_weight_position() to generate order_list # get the number of trading step finished, trade_step can be [0, 1, 2, ..., trade_len - 1] trade_step = self.trade_calendar.get_trade_step() trade_start_time, trade_end_time = self.trade_calendar.get_step_time( trade_step) pred_start_time, pred_end_time = self.trade_calendar.get_step_time( trade_step, shift=1) pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time) if pred_score is None: return TradeDecisionWO([], self) current_temp = copy.deepcopy(self.trade_position) assert isinstance(current_temp, Position) # Avoid InfPosition target_weight_position = self.generate_target_weight_position( score=pred_score, current=current_temp, trade_start_time=trade_start_time, trade_end_time=trade_end_time) order_list = self.order_generator.generate_order_list_from_target_weight_position( current=current_temp, trade_exchange=self.trade_exchange, risk_degree=self.get_risk_degree(trade_step), target_weight_position=target_weight_position, pred_start_time=pred_start_time, pred_end_time=pred_end_time, trade_start_time=trade_start_time, trade_end_time=trade_end_time, ) return TradeDecisionWO(order_list, self)
def generate_trade_decision(self, execute_result=None): # get the number of trading step finished, trade_step can be [0, 1, 2, ..., trade_len - 1] trade_step = self.trade_calendar.get_trade_step() trade_start_time, trade_end_time = self.trade_calendar.get_step_time( trade_step) pred_start_time, pred_end_time = self.trade_calendar.get_step_time( trade_step, shift=1) pred_score = self.signal.get_signal(start_time=pred_start_time, end_time=pred_end_time) # NOTE: the current version of topk dropout strategy can't handle pd.DataFrame(multiple signal) # So it only leverage the first col of signal if isinstance(pred_score, pd.DataFrame): pred_score = pred_score.iloc[:, 0] if pred_score is None: return TradeDecisionWO([], self) if self.only_tradable: # If The strategy only consider tradable stock when make decision # It needs following actions to filter stocks def get_first_n(li, n, reverse=False): cur_n = 0 res = [] for si in reversed(li) if reverse else li: if self.trade_exchange.is_stock_tradable( stock_id=si, start_time=trade_start_time, end_time=trade_end_time): res.append(si) cur_n += 1 if cur_n >= n: break return res[::-1] if reverse else res def get_last_n(li, n): return get_first_n(li, n, reverse=True) def filter_stock(li): return [ si for si in li if self.trade_exchange.is_stock_tradable( stock_id=si, start_time=trade_start_time, end_time=trade_end_time) ] else: # Otherwise, the stock will make decision with out the stock tradable info def get_first_n(li, n): return list(li)[:n] def get_last_n(li, n): return list(li)[-n:] def filter_stock(li): return li current_temp = copy.deepcopy(self.trade_position) # generate order list for this adjust date sell_order_list = [] buy_order_list = [] # load score cash = current_temp.get_cash() current_stock_list = current_temp.get_stock_list() # last position (sorted by score) last = pred_score.reindex(current_stock_list).sort_values( ascending=False).index # The new stocks today want to buy **at most** if self.method_buy == "top": today = get_first_n( pred_score[~pred_score.index.isin(last)].sort_values( ascending=False).index, self.n_drop + self.topk - len(last), ) elif self.method_buy == "random": topk_candi = get_first_n( pred_score.sort_values(ascending=False).index, self.topk) candi = list(filter(lambda x: x not in last, topk_candi)) n = self.n_drop + self.topk - len(last) try: today = np.random.choice(candi, n, replace=False) except ValueError: today = candi else: raise NotImplementedError(f"This type of input is not supported") # combine(new stocks + last stocks), we will drop stocks from this list # In case of dropping higher score stock and buying lower score stock. comb = pred_score.reindex(last.union( pd.Index(today))).sort_values(ascending=False).index # Get the stock list we really want to sell (After filtering the case that we sell high and buy low) if self.method_sell == "bottom": sell = last[last.isin(get_last_n(comb, self.n_drop))] elif self.method_sell == "random": candi = filter_stock(last) try: sell = pd.Index( np.random.choice(candi, self.n_drop, replace=False ) if len(last) else []) except ValueError: # No enough candidates sell = candi else: raise NotImplementedError(f"This type of input is not supported") # Get the stock list we really want to buy buy = today[:len(sell) + self.topk - len(last)] for code in current_stock_list: if not self.trade_exchange.is_stock_tradable( stock_id=code, start_time=trade_start_time, end_time=trade_end_time): continue if code in sell: # check hold limit time_per_step = self.trade_calendar.get_freq() if current_temp.get_stock_count( code, bar=time_per_step) < self.hold_thresh: continue # sell order sell_amount = current_temp.get_stock_amount(code=code) factor = self.trade_exchange.get_factor( stock_id=code, start_time=trade_start_time, end_time=trade_end_time) # sell_amount = self.trade_exchange.round_amount_by_trade_unit(sell_amount, factor) sell_order = Order( stock_id=code, amount=sell_amount, start_time=trade_start_time, end_time=trade_end_time, direction=Order.SELL, # 0 for sell, 1 for buy ) # is order executable if self.trade_exchange.check_order(sell_order): sell_order_list.append(sell_order) trade_val, trade_cost, trade_price = self.trade_exchange.deal_order( sell_order, position=current_temp) # update cash cash += trade_val - trade_cost # buy new stock # note the current has been changed current_stock_list = current_temp.get_stock_list() value = cash * self.risk_degree / len(buy) if len(buy) > 0 else 0 # open_cost should be considered in the real trading environment, while the backtest in evaluate.py does not # consider it as the aim of demo is to accomplish same strategy as evaluate.py, so comment out this line # value = value / (1+self.trade_exchange.open_cost) # set open_cost limit for code in buy: # check is stock suspended if not self.trade_exchange.is_stock_tradable( stock_id=code, start_time=trade_start_time, end_time=trade_end_time): continue # buy order buy_price = self.trade_exchange.get_deal_price( stock_id=code, start_time=trade_start_time, end_time=trade_end_time, direction=OrderDir.BUY) buy_amount = value / buy_price factor = self.trade_exchange.get_factor( stock_id=code, start_time=trade_start_time, end_time=trade_end_time) buy_amount = self.trade_exchange.round_amount_by_trade_unit( buy_amount, factor) buy_order = Order( stock_id=code, amount=buy_amount, start_time=trade_start_time, end_time=trade_end_time, direction=Order.BUY, # 1 for buy ) buy_order_list.append(buy_order) return TradeDecisionWO(sell_order_list + buy_order_list, self)