def judge(self, **kwargs): if not kwargs.has_key('deg_hisWindowPd') \ or not kwargs.has_key('deg_windowPd') \ or not kwargs.has_key('deg_60WindowPd') \ or not kwargs.has_key('lowBkCnt') \ or not kwargs.has_key('wave_score1') \ or not kwargs.has_key('wave_score2') \ or not kwargs.has_key('wave_score3'): ZLog.info('judge dlw kwargs error!') return if not hasattr(self, 'estimator') or not hasattr(self, MlFiterDlwJudgeClass.K_GOLDEN_DEG_PROB): ''' 暂时只info,如果有必要需要raise exception ''' ZLog.info('not estimator or prob') return w = np.array([kwargs['deg_hisWindowPd'], kwargs['deg_windowPd'], kwargs['deg_60WindowPd'], kwargs['lowBkCnt'], kwargs['wave_score1'], kwargs['wave_score2'], kwargs['wave_score3']]) prob_threshold = self.prob_threshold estimator = self.estimator prob = estimator.predict_proba(w.reshape(1, -1))[:, 1][0] if prob > prob_threshold: return True return False
def judge(self, **kwargs): if not kwargs.has_key('deg_hisWindowPd') \ or not kwargs.has_key('deg_windowPd') \ or not kwargs.has_key('deg_60WindowPd') \ or not kwargs.has_key('lowBkCnt') \ or not kwargs.has_key('wave_score1') \ or not kwargs.has_key('wave_score2') \ or not kwargs.has_key('wave_score3'): ZLog.info('judge dlw kwargs error!') return if not hasattr(self, 'estimator') or not hasattr( self, MlFiterDlwJudgeClass.K_GOLDEN_DEG_PROB): ''' 暂时只info,如果有必要需要raise exception ''' ZLog.info('not estimator or prob') return w = np.array([ kwargs['deg_hisWindowPd'], kwargs['deg_windowPd'], kwargs['deg_60WindowPd'], kwargs['lowBkCnt'], kwargs['wave_score1'], kwargs['wave_score2'], kwargs['wave_score3'] ]) prob_threshold = self.prob_threshold estimator = self.estimator prob = estimator.predict_proba(w.reshape(1, -1))[:, 1][0] if prob > prob_threshold: return True return False
def show_orders_hist(order_pd, s_list=None, q_default=10): if s_list is None: s_list = [ 'lowBkCnt', 'atr_std', 'jump_power', 'diff_days', 'wave_score1', 'wave_score2', 'wave_score3', 'deg_60WindowPd', 'deg_hisWindowPd', 'deg_windowPd' ] s_list = filter(lambda x: order_pd.columns.tolist().count(x) > 0, s_list) for sn in s_list: uq = len(np.unique(order_pd[sn])) if uq == 1: continue bins = 10 bins = uq // 50 if uq // 50 > bins else bins order_pd[sn].hist(bins=bins) plt.show() try: cats = pd.qcut(order_pd[sn], q_default) except Exception: ''' 某一个数据超出q的数量导致无法分 ''' import pandas.core.algorithms as algos bins = algos.quantile(np.unique(order_pd[sn]), np.linspace(0, 1, q_default + 1)) cats = pd.tools.tile._bins_to_cuts(order_pd[sn], bins, include_lowest=True) # ZLog.info(sn + ' qcut except use bins!') ZLog.info('{0} show hist and qcuts'.format(sn)) ZLog.info(cats.value_counts())
def print_progress(ind, last=False): if last or (ind > 0 and ind % K_PRINT_ITER == 0): ZLog.info('Iteration %d/%d\n' % (ind + 1, iter_n)) ZLog.debug(' content loss: %g\n' % org_loss.eval()) ZLog.debug(' style loss: %g\n' % style_loss.eval()) ZLog.debug(' tv loss: %g\n' % tv_loss.eval()) ZLog.debug(' total loss: %g\n' % loss.eval())
def show_orders_hist(order_pd, s_list=None, q_default=10): if s_list is None: s_list = ['lowBkCnt', 'atr_std', 'jump_power', 'diff_days', 'wave_score1', 'wave_score2', 'wave_score3', 'deg_60WindowPd', 'deg_hisWindowPd', 'deg_windowPd'] s_list = filter(lambda x: order_pd.columns.tolist().count(x) > 0, s_list) for sn in s_list: uq = len(np.unique(order_pd[sn])) if uq == 1: continue bins = 10 bins = uq // 50 if uq // 50 > bins else bins order_pd[sn].hist(bins=bins) plt.show() try: cats = pd.qcut(order_pd[sn], q_default) except Exception: ''' 某一个数据超出q的数量导致无法分 ''' import pandas.core.algorithms as algos bins = algos.quantile(np.unique(order_pd[sn]), np.linspace(0, 1, q_default + 1)) cats = pd.tools.tile._bins_to_cuts(order_pd[sn], bins, include_lowest=True) # ZLog.info(sn + ' qcut except use bins!') ZLog.info('{0} show hist and qcuts'.format(sn)) ZLog.info(cats.value_counts())
def fit(self): w = tf.Variable(tf.zeros([self.x_train.shape[1], self.y_train.shape[1]])) b = tf.Variable(tf.zeros([self.y_train.shape[1]])) activation = tf.nn.softmax(tf.matmul(self.x, w) + b) cost = -tf.reduce_sum(self.y * tf.log(activation)) optimizer = tf.train.GradientDescentOptimizer(self.learning_rate).minimize(cost) self.init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(self.init) for epoch in range(self.training_epochs): avg_cost = 0. if self.batch_size == -1: self.batch_size = int(self.x_train.shape[0] / 10) total_batch = int(self.x_train.shape[0] / self.batch_size) for i in range(total_batch): batch_xs = self.x_train[i * self.batch_size: (i + 1) * self.batch_size] batch_ys = self.y_train[i * self.batch_size: (i + 1) * self.batch_size] sess.run(optimizer, feed_dict={self.x: batch_xs, self.y: batch_ys}) avg_cost += sess.run(cost, feed_dict={self.x: batch_xs, self.y: batch_ys}) / total_batch ZLog.info("Optimization Finished!") self.pred = tf.argmax(activation, 1) if self.x_test is not None: correct_prediction = tf.equal(self.pred, tf.argmax(self.y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) ZLog.info("Accuracy:" + str(accuracy.eval({self.x: self.x_test, self.y: self.y_test})))
def feature_selection(self, **kwargs): x, y = kwargs['x'], kwargs['y'] fiter = self.get_fiter() selector = RFE(fiter) selector.fit(x, y) ZLog.info('RFE selection') ZLog.info( pd.DataFrame( { 'support': selector.support_, 'ranking': selector.ranking_ }, index=self.df.columns[1:])) selector = RFECV(fiter, cv=3, scoring='mean_squared_error') selector.fit(x, y) ZLog.newline() ZLog.info('RFECV selection') ZLog.info( pd.DataFrame( { 'support': selector.support_, 'ranking': selector.ranking_ }, index=self.df.columns[1:]))
def check_golden_mc_result(filter_ret, w_rate, symbol=None, bp=24.3, pf_cnt=200, loop_cnt=20000, p_outter_loop=1): """ 最后可视化验证少量的筛选结果 :param filter_ret: :param w_rate: :param symbol: :param bp: :param pf_cnt: :param loop_cnt: :param p_outter_loop: :return: """ if symbol is None: kl_pd = SymbolPd.make_kfold_pd('usNOAH')[-82:-40] else: kl_pd = SymbolPd.make_kfold_pd(symbol) for loc in np.arange(filter_ret.shape[0]): percents = ast.literal_eval(filter_ret['keys'].iloc[loc]) ZLog.info(loc) ZLog.info(percents) loss_percent = np.array(percents[0:4]) win_percent = np.array(percents[4:9]) profits_dict = {} golden_tuple = namedtuple('golden', ( 'below200', 'below250', 'below300', 'below382', 'above618', 'above700', 'above800', 'above900', 'above950')) _golden_mc_process_cmp(kl_pd, loss_percent, win_percent, golden_tuple, profits_dict, w_rate, bp, pf_cnt, p_outter_loop, loop_cnt, show=True)
def gmm_component_filter(self, nc=20, threshold=0.72, show=True): clf = GMM(nc, n_iter=500, random_state=3).fit(self.fiter.y) ss = clf.predict(self.fiter.y) self.fiter.df['p_rk_cg'] = self.fiter.df['profit_cg'].rank() self.fiter.df['ss'] = ss win_top = len(self.fiter.df['profit_cg']) - len( self.fiter.df['profit_cg']) * 0.25 loss_top = len(self.fiter.df['profit_cg']) * 0.25 self.fiter.df['rk'] = 0 self.fiter.df['rk'] = np.where(self.fiter.df['p_rk_cg'] > win_top, 1, self.fiter.df['rk']) self.fiter.df['rk'] = np.where(self.fiter.df['p_rk_cg'] < loss_top, -1, self.fiter.df['rk']) xt = pd.crosstab(self.fiter.df['ss'], self.fiter.df['rk']) xt_pct = xt.div(xt.sum(1).astype(float), axis=0) if show: xt_pct.plot(figsize=(16, 8), kind='bar', stacked=True, title=str('ss') + ' -> ' + str('result')) plt.xlabel(str('ss')) plt.ylabel(str('result')) ZLog.info(xt_pct[xt_pct[-1] > threshold]) ZLog.info(xt_pct[xt_pct[1] > threshold]) self.top_loss_ss = xt_pct[xt_pct[-1] > threshold].index self.top_win_ss = xt_pct[xt_pct[1] > threshold].index return xt, xt_pct
def gmm_component_filter(self, nc=20, threshold=0.72, show=True): clf = GMM(nc, n_iter=500, random_state=3).fit(self.fiter.y) ss = clf.predict(self.fiter.y) self.fiter.df['p_rk_cg'] = self.fiter.df['profit_cg'].rank() self.fiter.df['ss'] = ss win_top = len(self.fiter.df['profit_cg']) - len(self.fiter.df['profit_cg']) * 0.25 loss_top = len(self.fiter.df['profit_cg']) * 0.25 self.fiter.df['rk'] = 0 self.fiter.df['rk'] = np.where(self.fiter.df['p_rk_cg'] > win_top, 1, self.fiter.df['rk']) self.fiter.df['rk'] = np.where(self.fiter.df['p_rk_cg'] < loss_top, -1, self.fiter.df['rk']) xt = pd.crosstab(self.fiter.df['ss'], self.fiter.df['rk']) xt_pct = xt.div(xt.sum(1).astype(float), axis=0) if show: xt_pct.plot( figsize=(16, 8), kind='bar', stacked=True, title=str('ss') + ' -> ' + str('result')) plt.xlabel(str('ss')) plt.ylabel(str('result')) ZLog.info(xt_pct[xt_pct[-1] > threshold]) ZLog.info(xt_pct[xt_pct[1] > threshold]) self.top_loss_ss = xt_pct[xt_pct[-1] > threshold].index self.top_win_ss = xt_pct[xt_pct[1] > threshold].index return xt, xt_pct
def calc_above(self): orderPd = self.orderPd order_outer_diff_days = orderPd[(orderPd['diff_days'] == 0) | (orderPd['diff_days'] > self.dd_threshold)] self.above = order_outer_diff_days.result.value_counts()[ 1].sum() / order_outer_diff_days.result.value_counts().sum() ZLog.info('above win rate: ' + str(self.above)) return self.above
def calc_below(self): order_diff_days = self.orderPd[(self.orderPd['diff_days'] > 0) & ( self.orderPd['diff_days'] <= self.dd_threshold)] self.below = order_diff_days.result.value_counts()[1].sum( ) / order_diff_days.result.value_counts().sum() ZLog.info('below win rate: ' + str(self.below)) return self.below
def fit_img(self, img_path, resize=False, size=480, enhance=None, iter_n=10, **kwargs): ZLog.info('TensorPrismaClass miss fit_img!!')
def calc_above(self): orderPd = self.orderPd order_outer_diff_days = orderPd[(orderPd['diff_days'] == 0) | ( orderPd['diff_days'] > self.dd_threshold)] self.above = order_outer_diff_days.result.value_counts()[1].sum( ) / order_outer_diff_days.result.value_counts().sum() ZLog.info('above win rate: ' + str(self.above)) return self.above
def predict_kwargs(self, w_col, need_ind_cnt=1, **kwargs): for col in w_col: if col not in kwargs: ZLog.info('judge kwargs error!') return x = np.array([kwargs[col] for col in w_col]) x = x.reshape(1, -1) return self.predict(x, need_ind_cnt) == 1
def predict_hit_kwargs(self, w_col, **kwargs): for col in w_col: if col not in kwargs: ZLog.info('judge kwargs error!') return x = np.array([kwargs[col] for col in w_col]) x = x.reshape(1, -1) return self.hit_cnt(x)
def judge(self, **kwargs): for w in MlFiterDegPd.g_w_col: if w not in kwargs: ZLog.info('judge deg kwargs error!') return regex = MlFiterDegPd.g_regex_d w_col = MlFiterDegPd.g_w_col pd_class = MlFiterDegPdClass return self.do_judge(w_col, regex, pd_class, **kwargs)
def do_snn_tt(cls, x, y, n_folds=10, nn_hdim=3, num_passes=20000, print_loss=False): kf = KFold(len(y), n_folds=n_folds, shuffle=True) acs = list() for i, (train_index, test_index) in enumerate(kf): x_train, x_test = x[train_index], x[test_index] y_train, y_test = y[train_index], y[test_index] m_l__t_f = cls(x_train, y_train, x_test, y_test, nn_hdim=nn_hdim, num_passes=num_passes, print_loss=print_loss) accuracy = m_l__t_f.fit() acs.append(accuracy) ZLog.info('accuracys mean = {}'.format(np.array(acs).mean()))
def _do_cross_val_score(self, x, y, cv, scoring): fiter = self.get_fiter() scores = cross_validation.cross_val_score(fiter, x, y, cv=cv, scoring=scoring) mean_sc = np.mean(np.sqrt(-scores)) if scoring == 'mean_squared_error' \ else np.mean(scores) ZLog.info(scoring + ' mean: ' + str(mean_sc)) return scores
def make_boost_dummies(self, orderPd, cats_ss, prefix, regex): try: cats = pd.qcut(cats_ss, self.qcut_bins) except Exception, e: ''' 某一个数据超出q的数量导致无法分 ''' import pandas.core.algorithms as algos bins = algos.quantile(np.unique(cats_ss), np.linspace(0, 1, self.qcut_bins + 1)) cats = pd.tools.tile._bins_to_cuts(cats_ss, bins, include_lowest=True) ZLog.info(prefix + ' qcut except use bins!')
def show_golden_process(w_rate, symbol=None, mc_golden=False, bp=24.3, pf_cnt=200, loop_cnt=20000, outter_loop=1): if symbol is None: kl_pd = SymbolPd.make_kfold_pd('usNOAH')[-82:-40] else: kl_pd = SymbolPd.make_kfold_pd(symbol) golden = TLineGolden.calc_mc_golden( kl_pd, g_mc_percent, g_mc_loss_cnt) if mc_golden else TLineGolden.calc_golden(kl_pd) while outter_loop > 0: outter_loop -= 1 profits = [] for _ in np.arange(loop_cnt): wl = init_golden_w_full( golden, bp) if mc_golden else init_golden_wl(golden, bp) if wl is None: ZLog.info('init_golden_wl out of bp range!') return sp = 0 while wl is not None: supports = wl['supports'] resistances = wl['resistances'] w = np.random.binomial(1, w_rate) ''' sp = resistances[-1] sp = supports[0] -1, 0都行,反正这里走到有意义的sp时都是一个了 ''' if w: sp = resistances[-1] else: sp = supports[0] wl = golden_map_wl_grid(w, wl) else: """ -10 默认交易成本(手续费) """ pf = pf_cnt * (sp - bp) - 10 profits.append(pf) profits = pd.Series(profits) show = (outter_loop == 0) NpUtil.calc_regress_ang(profits.cumsum(), show) if show: profits.hist()
def fit(self): weights = { 'h1': tf.Variable(tf.random_normal([self.n_input, self.n_hidden_1])), 'h2': tf.Variable(tf.random_normal([self.n_hidden_1, self.n_hidden_2])), 'out': tf.Variable(tf.random_normal([self.n_hidden_2, self.n_classes])) } biases = { 'b1': tf.Variable(tf.random_normal([self.n_hidden_1])), 'b2': tf.Variable(tf.random_normal([self.n_hidden_2])), 'out': tf.Variable(tf.random_normal([self.n_classes])) } mul_predict = self.multilayer_perceptron(self.x, weights, biases) # Softmax loss cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(mul_predict, self.y)) # Adam Optimizer optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate).minimize(cost) self.init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(self.init) # Training cycle total_batch = int(len(self.x_train) / self.batch_size) + 1 tf.train.SummaryWriter(K_LOG_FILE, graph=sess.graph) for epoch in range(self.training_epochs): avg_cost = 0. perm = np.arange(len(self.x_train)) np.random.shuffle(perm) self.x_train = self.x_train[perm] self.y_train = self.y_train[perm] for i in range(total_batch): batch_xs = self.x_train[i * self.batch_size: (i + 1) * self.batch_size] batch_ys = self.y_train[i * self.batch_size: (i + 1) * self.batch_size] # Fit training using batch data sess.run(optimizer, feed_dict={self.x: batch_xs, self.y: batch_ys}) # Compute average loss avg_cost += sess.run(cost, feed_dict={self.x: batch_xs, self.y: batch_ys}) / total_batch if epoch % self.display_step == 0: print "Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost) ZLog.info("Optimization Finished!") self.pred = tf.argmax(mul_predict, 1) if self.x_test is not None: correct_prediction = tf.equal(tf.argmax(mul_predict, 1), tf.argmax(self.y, 1)) accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) ac = accuracy.eval({self.x: self.x_test, self.y: self.y_test}) ZLog.info("Accuracy:" + str(ac)) return ac
def _do_collect_work(self): with ThreadPoolExecutor(max_workers=len(self.back_proxys) * 3) as executor: """ 这里使用线程池还是因为代理的质量太差了, 要控制线程数量 """ thread_lock = threading.RLock() all_same_cnt = 0 while True: soup = BeautifulSoup(self.driver.page_source, "lxml") img_objs = soup.select('#imgid > div > ul > li[data-objurl]') sub_same_cnt = 0 for img in img_objs: url = img['data-objurl'] url_thumb = img['data-thumburl'] if self.requested_url.count(url) > 0: sub_same_cnt += 1 continue url_dict = {'url': url, 'url_thumb': url_thumb} if g_enable_debug: self.down_load_img(url_dict, thread_lock) else: executor.submit(self.down_load_img, url_dict, thread_lock) # 就在这里append否则里面还要线程同步 self.requested_url.append(url) js = "window.scrollTo({}, {})".format( self.current_pos, self.current_pos + K_SCROLL_MOVE_DISTANCE) self.current_pos += K_SCROLL_MOVE_DISTANCE self.driver.execute_script(js) time.sleep(K_SCROLL_SLEEP_TIME) """ 所有都在requested中记录全等一次否则重置 """ if sub_same_cnt == len(img_objs): all_same_cnt += 1 else: all_same_cnt = 0 """ 达到一定次数,认为到底部了 """ if all_same_cnt > 30: break if self.collect_cnt >= K_COLLECT_CNT: ZLog.info('collect_cnt > K_COLLECT_CNT task end') break
def calc_similar(symbol, cmp_symbol, sc=slice(0, 2), show=True): """ sc: 使用几个维度相似性验证的选择切片 默认使用: E_CORE_TASK_CG_PEARS = 0 E_CORE_TASK_CG_SPERM = 1 如只想使用SPERM sc=slice(1, 2) 对比的股票在rank中的位置分量 """ pd_list = get_pdlist(sc) sum_rank = get_sum_rank(pd_list, symbol) cmp_rank = sum_rank.sort_values(ascending=True).index.tolist().index(cmp_symbol) rank_score = 1 - cmp_rank / sum_rank.shape[0] if show: ZLog.info(symbol + ' similar rank score' + cmp_symbol + ' :' + str(rank_score)) mul_pd = SymbolPd.make_kfold_mulpd([symbol, cmp_symbol]) klpd_symbol = SymbolPd.get_n_year(mul_pd[symbol], from_year=2) klpd_cmp_symbol = SymbolPd.get_n_year(mul_pd[cmp_symbol], from_year=2) """ 缩放到同一个数量级 """ kl_pd_symbol_nrm, klpd_cmp_symbol_nrm = NpUtil.two_mean_list(klpd_symbol.close, klpd_cmp_symbol.close, type_look='look_max') kl_pd_symbol_nrm.plot() klpd_cmp_symbol_nrm.plot() plt.legend([symbol, cmp_symbol]) plt.title('similar draw') plt.show() distance = (kl_pd_symbol_nrm - klpd_cmp_symbol_nrm) distance_mean = distance.mean() distance_std = distance.std() above = distance_mean + distance_std below = distance_mean - distance_std distance.plot() plt.axhline(distance_mean, color='r', linestyle='--') plt.axhline(above, color='c') plt.axhline(below, color='g') plt.title('similar distance') plt.legend(['distance', 'distance_mean', 'distance above', 'distance below'], bbox_to_anchor=(1.05, 1), loc=2, borderaxespad=0.) plt.show() return rank_score
def choose_cprs_component(self, llps): """ :param llps: cprs[(so.cprs['lps'] < 0) & (so.cprs['lms'] < -0.0)] 你所需要的符合筛选条件的cprs :return: """ if not hasattr(self, 'cprs'): raise ValueError('gmm_component_filter not exe!!!! ') nts_pd = pd.DataFrame() for nk in llps.index: nts_pd = nts_pd.append(self.nts[nk]) nts_pd = nts_pd.drop_duplicates(subset='ind', keep='last') ZLog.info('nts_pd.shape = {0}'.format(nts_pd.shape)) loss_rate = nts_pd.result.value_counts()[0] / nts_pd.result.value_counts().sum() win_rate = nts_pd.result.value_counts()[1] / nts_pd.result.value_counts().sum() ZLog.info('nts_pd loss rate = {0}'.format(loss_rate)) improved = (nts_pd.shape[0] / self.fiter.order_has_ret.shape[0]) * (loss_rate - win_rate) ZLog.info('improved rate = {0}'.format(improved)) xt = self.fiter.order_has_ret.result.value_counts() ZLog.info('predict win rate = ' + str(xt[1] / xt.sum() + improved)) nts_pd.sort_index()['profit'].cumsum().plot() plt.show()
def do_thread_work(self, proxy, checked_list, thread_lock): if proxy['type'] == 'HTTP': proxy_dict = dict(http='http://{}'.format(proxy['proxy']), https='http://{}'.format(proxy['proxy'])) else: proxy_dict = dict(http='socks5://{}'.format(proxy['proxy']), https='socks5://{}'.format(proxy['proxy'])) try: # r = requests.post("https://www.baidu.com/", headers=self.headers, proxies=proxy_dict, timeout=15, # verify=False) img_url = 'http://picm.bbzhi.com/dongwubizhi/labuladuoxunhuiquanbizhi/animal_' \ 'labrador_retriever_1600x1200_44243_m.jpg' enable_stream = False if enable_stream: response = requests.get(img_url, headers=self.headers, proxies=proxy_dict, timeout=15, stream=True) if response.status_code == 200: test_name = '../gen/check_proxy.jpg' with open(test_name, 'wb') as f: for chunk in response.iter_content(chunk_size=1024): if chunk: f.write(chunk) f.flush() check_img = PIL.Image.open(test_name) check_img.close() else: response = requests.get(img_url, headers=self.headers, proxies=proxy_dict, timeout=(10, 20)) if response.status_code == 200: test_name = '../gen/check_proxy.jpg' with open(test_name, 'wb') as f: f.write(response.content) f.flush() check_img = PIL.Image.open(test_name) check_img.close() except Exception as e: # ZLog.exception(e) return with thread_lock: ZLog.info('{} check ok'.format(proxy['proxy'])) checked_list.append(proxy)
def down_load_img(self, url_dict, thread_lock): img_url = url_dict['url'] img_url_thumb = url_dict['url_thumb'] file_name = self.img_dir + Md5Helper.mkmd5frombinary(img_url) + '.jpg' if ZCommonUtil.file_exist(file_name): ZLog.debug('{} has already exist'.format(img_url)) """ 也还是应该算成功收集了 """ with thread_lock: self.collect_cnt += 1 return def begin_req(a_proxy): headers = {"User-Agent": K_UA} if self.proxy['type'] == 'HTTP': proxy_dict = dict(http='http://{}'.format(a_proxy['proxy']), https='http://{}'.format(a_proxy['proxy'])) else: proxy_dict = dict(http='socks5://{}'.format(a_proxy['proxy']), https='socks5://{}'.format(a_proxy['proxy'])) try: if g_enable_stream: return self._down_load_img_stream( img_url, file_name, headers, proxy_dict, thread_lock, img_url_thumb=img_url_thumb) else: return self._down_load_img_direct( img_url, file_name, headers, proxy_dict, thread_lock, img_url_thumb=img_url_thumb) except Exception: # ZLog.exception(e) return False bps = self.back_proxys[:] random.shuffle(bps) for proxy in bps: if begin_req(proxy): break
def scores(self, y_pre, y=None): ZLog.info('scores(self, y_pre, y=None)') _, y = self.proxy_xy(None, y) ZLog.info("accuracy = %.2f" % (accuracy_score(y, y_pre))) ZLog.info("precision_score = %.2f" % (metrics.precision_score(y, y_pre))) ZLog.info("recall_score = %.2f" % (metrics.recall_score(y, y_pre))) self._confusion_matrix_with_report(y, y_pre)
def judge(self, **kwargs): for w in MlFiterGoldenPd.g_w_col: if w not in kwargs: ZLog.info('judge golden kwargs error!') return regex = MlFiterGoldenPd.g_regex_d """ 要保持和mertics做的pd一样的顺序 """ w_col = MlFiterGoldenPd.g_w_col pd_class = MlFiterGoldenPdClass return self.do_judge(w_col, regex, pd_class, **kwargs)
def _do_cross_val_score(self, x, y, cv, scoring): fiter = self.get_fiter() scores = cross_validation.cross_val_score(fiter, x, y, cv=cv, scoring=scoring) mean_sc = np.mean(np.sqrt(-scores)) if scoring == 'mean_squared_error' \ else np.mean(scores) ZLog.info(scoring + ' mean: ' + str(mean_sc)) return scores
def _confusion_matrix_with_report(self, test_y, predictions): confusion_matrix = metrics.confusion_matrix(test_y, predictions) print("Confusion Matrix ", confusion_matrix) print(" Predicted") print(" | 0 | 1 |") print(" |-----|-----|") print(" 0 | %3d | %3d |" % (confusion_matrix[0, 0], confusion_matrix[0, 1])) print("Actual |-----|-----|") print(" 1 | %3d | %3d |" % (confusion_matrix[1, 0], confusion_matrix[1, 1])) print(" |-----|-----|") ''' 一般情况下loss, win可以概括 ''' ZLog.info(classification_report(test_y, predictions))
def check_golden_mc_result(filter_ret, w_rate, symbol=None, bp=24.3, pf_cnt=200, loop_cnt=20000, p_outter_loop=1): """ 最后可视化验证少量的筛选结果 :param filter_ret: :param w_rate: :param symbol: :param bp: :param pf_cnt: :param loop_cnt: :param p_outter_loop: :return: """ if symbol is None: kl_pd = SymbolPd.make_kfold_pd('usNOAH')[-82:-40] else: kl_pd = SymbolPd.make_kfold_pd(symbol) for loc in np.arange(filter_ret.shape[0]): percents = ast.literal_eval(filter_ret['keys'].iloc[loc]) ZLog.info(loc) ZLog.info(percents) loss_percent = np.array(percents[0:4]) win_percent = np.array(percents[4:9]) profits_dict = {} golden_tuple = namedtuple( 'golden', ('below200', 'below250', 'below300', 'below382', 'above618', 'above700', 'above800', 'above900', 'above950')) _golden_mc_process_cmp(kl_pd, loss_percent, win_percent, golden_tuple, profits_dict, w_rate, bp, pf_cnt, p_outter_loop, loop_cnt, show=True)
def scores(self, y_pre, y=None): ZLog.info('scores(self, y_pre, y=None)') _, y = self.proxy_xy(None, y) ZLog.info("accuracy = %.2f" % (accuracy_score(y, y_pre))) ZLog.info("precision_score = %.2f" % (metrics.precision_score(y, y_pre))) ZLog.info("recall_score = %.2f" % (metrics.recall_score(y, y_pre))) self._confusion_matrix_with_report(y, y_pre)
def importances_coef_pd(self, **kwargs): if not hasattr(self, 'df'): raise ValueError('please make a df func first!') x, y = kwargs['x'], kwargs['y'] fiter = self.get_fiter() fiter.fit(x, y) self.echo_info(fiter) if hasattr(fiter, 'feature_importances_'): return pd.DataFrame( {'feature': list(self.df.columns)[1:], 'importance': fiter.feature_importances_}).sort_values( 'importance') elif hasattr(fiter, 'coef_'): return pd.DataFrame({"columns": list(self.df.columns)[1:], "coef": list(fiter.coef_.T)}) else: ZLog.info('fiter not hasattr feature_importances_ or coef_!')
def feature_selection(self, **kwargs): x, y = kwargs['x'], kwargs['y'] fiter = self.get_fiter() selector = RFE(fiter) selector.fit(x, y) ZLog.info('RFE selection') ZLog.info(pd.DataFrame({'support': selector.support_, 'ranking': selector.ranking_}, index=self.df.columns[1:])) selector = RFECV(fiter, cv=3, scoring='mean_squared_error') selector.fit(x, y) ZLog.newline() ZLog.info('RFECV selection') ZLog.info(pd.DataFrame({'support': selector.support_, 'ranking': selector.ranking_}, index=self.df.columns[1:]))
def show_golden_process(w_rate, symbol=None, mc_golden=False, bp=24.3, pf_cnt=200, loop_cnt=20000, outter_loop=1): if symbol is None: kl_pd = SymbolPd.make_kfold_pd('usNOAH')[-82:-40] else: kl_pd = SymbolPd.make_kfold_pd(symbol) golden = TLineGolden.calc_mc_golden(kl_pd, g_mc_percent, g_mc_loss_cnt) if mc_golden else TLineGolden.calc_golden( kl_pd) while outter_loop > 0: outter_loop -= 1 profits = [] for _ in np.arange(loop_cnt): wl = init_golden_w_full(golden, bp) if mc_golden else init_golden_wl(golden, bp) if wl is None: ZLog.info('init_golden_wl out of bp range!') return sp = 0 while wl is not None: supports = wl['supports'] resistances = wl['resistances'] w = np.random.binomial(1, w_rate) ''' sp = resistances[-1] sp = supports[0] -1, 0都行,反正这里走到有意义的sp时都是一个了 ''' if w: sp = resistances[-1] else: sp = supports[0] wl = golden_map_wl_grid(w, wl) else: """ -10 默认交易成本(手续费) """ pf = pf_cnt * (sp - bp) - 10 profits.append(pf) profits = pd.Series(profits) show = (outter_loop == 0) NpUtil.calc_regress_ang(profits.cumsum(), show) if show: profits.hist()
def _down_load_img_direct(self, img_url, file_name, headers, proxy_dict, thread_lock, img_url_thumb=None): response = requests.get(img_url, headers=headers, proxies=proxy_dict, timeout=(15, 360)) if response.status_code == 200: try: with open(file_name, 'wb') as f: f.write(response.content) f.flush() """ 检测ok了,才可以,暂时就先算了, 需要添加重试次数限制 """ check_img = PIL.Image.open(file_name) check_img.verify() check_img.close() except Exception: os.remove(file_name) return True with thread_lock: self.collect_cnt += 1 if img_url_thumb is None: ZLog.debug('down_load_img img_url_thumb ok!') return True else: if img_url_thumb is None: ZLog.debug('down_load_img fail url={} code={}'.format( img_url, response.status_code)) return False """ 原始地址下载失败,改为下载thumb,要是再失败了就失败了 """ return self._down_load_img_stream(img_url_thumb, file_name, headers, proxy_dict, thread_lock, img_url_thumb=None)
def do_judge(self, w_col, regex_dummies, pd_class, **kwargs): if not hasattr(self, 'estimator') or not hasattr(self, 'prob_threshold') \ or not hasattr(self, 'dummies') \ or not hasattr(self, 'invoke_hmm') or not hasattr(self, 'invoke_pca'): ''' 暂时只info,如果有必要需要raise exception ''' ZLog.info('not estimator or prob or dhp') return True w = np.array([kwargs[col] for col in w_col]) w = w.reshape(1, -1) prob_threshold = self.prob_threshold estimator = self.estimator dummies = self.dummies invoke_hmm = self.invoke_hmm invoke_pca = self.invoke_pca df = None if dummies or invoke_hmm: df = pd.DataFrame(w) df.columns = w_col if dummies and df is not None: df_dummies = pd_class.dummies_xy(df) regex = regex_dummies df = df_dummies.filter(regex=regex) w = df.as_matrix() if invoke_hmm: ''' 只是置换出hmm形式的x值,这里的df没有修改,暂时也没有必要 ''' w = pd_class.hmm_predict(self, w).reshape(1, -1) elif invoke_pca: ''' elif 互斥 ''' w = pd_class.pca_predict(self, w).reshape(1, -1) prob = estimator.predict_proba(w)[:, 1][0] if prob > prob_threshold: return True return False
def _confusion_matrix_with_report(self, test_y, predictions): confusion_matrix = metrics.confusion_matrix(test_y, predictions) print("Confusion Matrix ", confusion_matrix) print(" Predicted") print(" | 0 | 1 |") print(" |-----|-----|") print(" 0 | %3d | %3d |" % (confusion_matrix[0, 0], confusion_matrix[0, 1])) print("Actual |-----|-----|") print(" 1 | %3d | %3d |" % (confusion_matrix[1, 0], confusion_matrix[1, 1])) print(" |-----|-----|") ''' 一般情况下loss, win可以概括 ''' ZLog.info(classification_report(test_y, predictions))
def check_proxy(self): checked_list = list() thread_lock = threading.RLock() thread_array = [] for proxy in self.proxy_list: # self.do_thread_work(proxy, checked_list, thread_lock) t = threading.Thread(target=self.do_thread_work, args=( proxy, checked_list, thread_lock,)) t.setDaemon(True) t.start() thread_array.append(t) for t in thread_array: t.join() self.proxy_list = checked_list ZLog.info('proxy_list len={}'.format(len(self.proxy_list)))
def plot_confusion_matrices(estimator, x, y, n_folds=10): y_pred = run_cv_estimator(estimator, x, y, n_folds=n_folds) class_names = np.unique(y).tolist() confusion_matrix = metrics.confusion_matrix(y, y_pred) ZLog.info(confusion_matrix) fig = plt.figure() ax = fig.add_subplot(111) cax = ax.matshow(confusion_matrix) plt.title('Confusion matrix for %s' % estimator.__class__.__name__) fig.colorbar(cax) ax.set_xticklabels([''] + class_names) ax.set_yticklabels([''] + class_names) plt.xlabel('Predicted') plt.ylabel('True') plt.show()
def __init_work(self, a_proxy): try: if g_enable_show: chrome_options = webdriver.ChromeOptions() chrome_options.add_argument('--proxy-server={}://{}'.format( a_proxy['type'].lower(), a_proxy['proxy'])) if g_enable_proxy: self.driver = webdriver.Chrome( chrome_options=chrome_options) else: self.driver = webdriver.Chrome() else: d_cap = dict(DesiredCapabilities.PHANTOMJS) d_cap["phantomjs.page.settings.userAgent"] = (K_UA) service_args = [ '--proxy={}'.format(a_proxy['proxy']), '--proxy-type={}'.format(a_proxy['type']), ] if g_enable_proxy: self.driver = webdriver.PhantomJS( executable_path=K_PJS_PATH, desired_capabilities=d_cap, service_args=service_args) else: self.driver = webdriver.PhantomJS( executable_path=K_PJS_PATH, desired_capabilities=d_cap) self.requested_url = list() """ scroll bar 当前位置 """ self.current_pos = 0 """ 总成功收集数量 """ self.collect_cnt = 0 self.driver.get("http://image.baidu.com/") return True except Exception as e: ZLog.exception(e) return False
def do_tf_tt(cls, x, y, n_folds=10, **kwargs): """ 如果需要扩张除init四个外的参数, 子类继续自己扩张把 :param x: :param y: :param n_folds: :return: """ kf = KFold(len(y), n_folds=n_folds, shuffle=True) acs = list() for i, (train_index, test_index) in enumerate(kf): x_train, x_test = x[train_index], x[test_index] y_train, y_test = y[train_index], y[test_index] m_l__t_f = cls(x_train, y_train, x_test, y_test, **kwargs) ac = m_l__t_f.fit() if ac is not None: acs.append(ac) if len(acs) > 0: ZLog.info('acs mean = {}'.format(np.array(acs).mean()))
def graphviz_tree(estimator, features, x, y): if not hasattr(estimator, 'tree_'): ZLog.info('only tree can graphviz!') return estimator.fit(x, y) tree.export_graphviz(estimator.tree_, out_file='graphviz.dot', feature_names=features) os.system("dot -T png graphviz.dot -o graphviz.png") ''' !open $path 要是方便用notebook直接open其实显示效果好,plt,show的大小不好调整 ''' # path = ZEnv.shell_cmd_result('pwd') + '/graphviz.png' # !open $path image_file = cbook.get_sample_data(ZEnv.shell_cmd_result('pwd') + '/graphviz.png') image = plt.imread(image_file) plt.imshow(image) plt.axis('off') # clear x- and y-axes plt.show()
def stats_max_winth(order): try: bd = order['buy Date'] kp = order['keep_days'] ''' n_folds=3多来一个,避免由于cap对齐造成的缺失 ''' kl_pd = SymbolPd.make_kfold_pd(order.Symbol, cap=cap) b_key = kl_pd[kl_pd['date'] == bd].key.values[0] ''' bKey + 1 第一天的return不计算,factor赞按照mean买入,可以认为 符合正态分布,均值是0 ''' maxth = kl_pd[b_key + 1: b_key + kp + 1].netChangeRatio.cumsum().max() maxth95 = maxth if kp >= keep95 or (b_key + keep95 + 1) > kl_pd.shape[0] \ else kl_pd[b_key + 1:b_key + keep95 + 1].netChangeRatio.cumsum().max() except Exception, e: # import pdb # pdb.set_trace() ShowMsg.show_msg('Exception', e.__str__) ZLog.debug(e.__str__) ZLog.debug(bd) ZLog.debug(kl_pd) return 0, 0
def show_general(self, use_fiter=False): order_has_ret_fit = self.fiter.order_has_ret if use_fiter else self.orders_pd[self.orders_pd['result'] <> 0] ZLog.info('all fit order = ' + str(order_has_ret_fit.shape)) xt = order_has_ret_fit.result.value_counts() ZLog.info('win rate = ' + str(xt[1] / xt.sum())) ZLog.info('profit_cg.sum() = ' + str(order_has_ret_fit.profit_cg.sum())) order_has_ret_fit.sort_values('buy Date')['profit_cg'].cumsum().plot(grid=True, title='profit_cg cumsum') profit_cg_win_mean = order_has_ret_fit[order_has_ret_fit['profit_cg'] > 0].profit_cg.mean() profit_cg_loss_mean = order_has_ret_fit[order_has_ret_fit['profit_cg'] < 0].profit_cg.mean() ZLog.info('win mean = {0} loss_mean = {1} '.format(profit_cg_win_mean, profit_cg_loss_mean)) plt.show()
def train_test_split_df(self, df=None, test_size=0.1, random_state=0): if df is None: df = self.df train_df, cv_df = train_test_split(df, test_size=test_size, random_state=random_state) fiter = self.get_fiter() fiter.fit(train_df.as_matrix()[:, 1:], train_df.as_matrix()[:, 0]) predictions = fiter.predict(cv_df.as_matrix()[:, 1:]) ZLog.info("accuracy = %.2f" % (accuracy_score(cv_df.as_matrix()[:, 0], predictions))) ZLog.info("precision_score = %.2f" % (metrics.precision_score(cv_df.as_matrix()[:, 0], predictions))) ZLog.info("recall_score = %.2f" % (metrics.recall_score(cv_df.as_matrix()[:, 0], predictions))) self._confusion_matrix_with_report(cv_df.as_matrix()[:, 0], predictions)
def plot_roc_estimator(self, x=None, y=None): x, y = self.proxy_xy(x, y) fiter = self.get_fiter() ZLog.info(fiter.__class__.__name__ + ' :roc') MlFiterExcute.plot_roc_estimator(fiter, x, y)
def train_test_split_xy(self, x=None, y=None, test_size=0.1, random_state=0): x, y = self.proxy_xy(x, y) train_x, test_x, train_y, test_y = train_test_split(x, y, test_size=test_size, random_state=random_state) ZLog.info(x.shape, y.shape) ZLog.info(train_x.shape, train_y.shape) ZLog.info(test_x.shape, test_y.shape) fiter = self.get_fiter() clf = fiter.fit(train_x, train_y) predictions = clf.predict(test_x) ZLog.info("accuracy = %.2f" % (accuracy_score(test_y, predictions))) ZLog.info("precision_score = %.2f" % (metrics.precision_score(test_y, predictions))) ZLog.info("recall_score = %.2f" % (metrics.recall_score(test_y, predictions))) self._confusion_matrix_with_report(test_y, predictions)
def verify_process(est_cls, judge_cls, make_x_func, make_order_func, order_pd, only_jd=False, first_local=False, tn_threshold=800): """ :param est_cls: :param judge_cls: :param make_x_func: :param make_order_func: :param order_pd: :param only_jd: 使用以序列化的只进行judge :param first_local: 优先使用本地分类器 :param tn_threshold: :return: """ if not only_jd: _, _, _, _, _, _ = est_cls.dump_process(judge_cls, order_pd, tn_threshold, True, first_local=first_local) def apply_judge(order, p_make_x_func): x = p_make_x_func(order) """ 离散不使用隐因子 """ d_ret = est_cls.do_predict_process(judge_cls, True, False, False, **x) """ 连续不使用隐因子 """ v_ret = est_cls.do_predict_process(judge_cls, False, False, False, **x) """ 离散使用隐因子 """ dm_ret = est_cls.do_predict_process(judge_cls, True, True, False, **x) """ 连续使用隐因子 """ vm_ret = est_cls.do_predict_process(judge_cls, False, True, False, **x) """ 离散使用pca """ dp_ret = est_cls.do_predict_process(judge_cls, True, False, True, **x) """ 连续使用pca """ vp_ret = est_cls.do_predict_process(judge_cls, False, False, True, **x) return d_ret, v_ret, dm_ret, vm_ret, dp_ret, vp_ret order_has_ret = make_order_func(order_pd) jd_ret = order_pd.apply(apply_judge, axis=1, args=(make_x_func,)) order_has_ret['d_ret'] = [1 if ret[0] else 0 for ret in jd_ret] order_has_ret['v_ret'] = [1 if ret[1] else 0 for ret in jd_ret] order_has_ret['dm_ret'] = [1 if ret[2] else 0 for ret in jd_ret] order_has_ret['vm_ret'] = [1 if ret[3] else 0 for ret in jd_ret] order_has_ret['dp_ret'] = [1 if ret[4] else 0 for ret in jd_ret] order_has_ret['vp_ret'] = [1 if ret[5] else 0 for ret in jd_ret] v_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['v_ret'] == 0]['result'], order_has_ret[order_has_ret['v_ret'] == 0]['v_ret']) ZLog.info('v_ret_result: ' + str(v_ret_result)) d_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['d_ret'] == 0]['result'], order_has_ret[order_has_ret['d_ret'] == 0]['d_ret']) ZLog.info('d_ret_result: ' + str(d_ret_result)) dp_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['dp_ret'] == 0]['result'], order_has_ret[order_has_ret['dp_ret'] == 0]['dp_ret']) ZLog.info('dp_ret_result: ' + str(dp_ret_result)) vp_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['vp_ret'] == 0]['result'], order_has_ret[order_has_ret['vp_ret'] == 0]['vp_ret']) ZLog.info('vp_ret_result: ' + str(vp_ret_result)) dm_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['dm_ret'] == 0]['result'], order_has_ret[order_has_ret['dm_ret'] == 0]['dm_ret']) ZLog.info('dm_ret_result: ' + str(dm_ret_result)) vm_ret_result = metrics.accuracy_score(order_has_ret[order_has_ret['vm_ret'] == 0]['result'], order_has_ret[order_has_ret['vm_ret'] == 0]['vm_ret']) ZLog.info('vm_ret_result: ' + str(vm_ret_result)) ZLog.newline(fill_cnt=58) v_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['v_ret']) ZLog.info('v_ret_result_all: ' + str(v_ret_result_all)) d_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['d_ret']) ZLog.info('d_ret_result_all: ' + str(d_ret_result_all)) dp_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['dp_ret']) ZLog.info('dp_ret_result_all: ' + str(dp_ret_result_all)) vp_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['vp_ret']) ZLog.info('vp_ret_result_all: ' + str(vp_ret_result_all)) dm_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['dm_ret']) ZLog.info('dm_ret_result_all: ' + str(dm_ret_result_all)) vm_ret_result_all = metrics.accuracy_score(order_has_ret['result'], order_has_ret['vm_ret']) ZLog.info('vm_ret_result_all: ' + str(vm_ret_result_all)) ZLog.newline(fill_cnt=58) order_has_ret['vdmret'] = order_has_ret['d_ret'] + order_has_ret['v_ret'] + order_has_ret['dp_ret'] + order_has_ret[ 'vp_ret'] order_has_ret['vdmret'].value_counts().plot(kind='barh') plt.title('vdmret barh') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['v_ret'] == 1)).value_counts().plot(kind='bar') plt.title('v_ret == 1') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['d_ret'] == 1)).value_counts().plot(kind='bar') plt.title('d_ret == 1') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['vm_ret'] == 1)).value_counts().plot(kind='bar') plt.title('vm_ret == 1') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['dm_ret'] == 1)).value_counts().plot(kind='bar') plt.title('dm_ret == 1') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['dp_ret'] == 1)).value_counts().plot(kind='bar') plt.title('dp_ret == 1') plt.show() ((order_has_ret['vdmret'] == 1) & (order_has_ret['vp_ret'] == 1)).value_counts().plot(kind='bar') plt.title('vp_ret == 1') plt.show() final_result = metrics.accuracy_score(order_has_ret[order_has_ret['vdmret'] == 0]['result'], order_has_ret[order_has_ret['vdmret'] == 0]['vdmret']) ZLog.info('final_result: ' + str(final_result)) order_has_ret['vdmret_one'] = np.where(order_has_ret['vdmret'] == 1, 0, 1) final_one_result = metrics.accuracy_score(order_has_ret[order_has_ret['vdmret_one'] == 0]['result'], order_has_ret[order_has_ret['vdmret_one'] == 0]['vdmret_one']) ZLog.info('final_one_result: ' + str(final_one_result)) order_has_ret['vdmret_two'] = np.where(order_has_ret['vdmret'] == 2, 0, 1) final_two_result = metrics.accuracy_score(order_has_ret[order_has_ret['vdmret_two'] == 0]['result'], order_has_ret[order_has_ret['vdmret_two'] == 0]['vdmret_two']) ZLog.info('final_two_result: ' + str(final_two_result)) order_has_ret['vdmret_three'] = np.where(order_has_ret['vdmret'] == 3, 0, 1) final_three_result = metrics.accuracy_score(order_has_ret[order_has_ret['vdmret_three'] == 0]['result'], order_has_ret[order_has_ret['vdmret_three'] == 0]['vdmret_three']) ZLog.info('final_three_result: ' + str(final_three_result)) order_has_ret['vdmret_four'] = np.where(order_has_ret['vdmret'] == 4, 0, 1) final_four_result = metrics.accuracy_score(order_has_ret[order_has_ret['vdmret_four'] == 0]['result'], order_has_ret[order_has_ret['vdmret_four'] == 0]['vdmret_four']) ZLog.info('final_four_result: ' + str(final_four_result)) return jd_ret, order_has_ret