克隆策略

In [2]:

# 本代码由可视化策略环境自动生成 2021年5月27日17:41
# 本代码单元只能在可视化模式下编辑。您也可以拷贝代码，粘贴到新建的代码单元或者策略，然后修改。


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m5_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    dt = input_1.read()
    start_date = dt['date'].iloc[0].strftime('%Y-%m-%d')
    end_date = dt['date'].iloc[-1].strftime('%Y-%m-%d')
    instruments = dt['instrument'].unique()
    dic = {'instruments':instruments,'start_date':start_date,'end_date':end_date}
    data_1 = DataSource.write_pickle(dic)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m5_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m20_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = input_1.read()
    data_1 = DataSource.write_df(df[['date','instrument','close', 'Trend_Strength', 'ret_skew', 'ret_kurt']])
    return Outputs(data_1=data_1, data_2=None, data_3=None)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m20_post_run_bigquant_run(outputs):
    return outputs

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m2_run_bigquant_run(input_1, input_2, start_date, end_date, rabalance_period, buy_commission_rate, sell_commission_rate, 
                 ic_method, quantile_num, is_standardlize, is_winsorize):
    import time
    import bigexpr
    
    from bigshared.common.biglogger import BigLogger
    
    # print(start_date,end_date)
    class FuturesPerformance:
        def __init__(
            self,
            log,
            start_date=None,
            end_date=None,
            rabalance_period=22,
            buy_commission_rate=0.0005,
            sell_commission_rate=0.0005,
            ic_method="Rank_IC",
            quantile_num=5,
            is_standardlize=True,
            is_winsorize=True,
        ):
            self.log = log
            self.start_date = start_date
            self.end_date = end_date
            self.rabalance_period = rabalance_period  # 调仓天数
            self.buy_commission_rate = buy_commission_rate  # 买入佣金(百分比)
            self.sell_commission_rate = sell_commission_rate  # 卖出佣金（百分比）
            self.ic_method = ic_method
            self.quantile_num = quantile_num
            self.is_standardlize = is_standardlize  # 是否标准化
            self.is_winsorize = is_winsorize  # 是否去极值
        
        def data_processing(self, continus_contract_df, factor_expr):
            # 表达式抽取
            start_time = time.time()
            self.log.info("data_processing start ...")

            def _handle_data(df, assignment_value, price_type):
                # 计算当期因子和未来一段时间收益率
                # df["factor"] = df["close"] / df["close"].shift(44) - 1  # 构建因子
                df["factor"] = bigexpr.evaluate(df, assignment_value, None)
                # 持有期收益率
                df["ret"] = df[price_type].shift(-1 * self.rabalance_period) / df[price_type] - 1
                df['ret'] = df.ret.shift(-1)  # 下一期的收益率
                df['daily_ret_1'] = df['close'].pct_change().shift(-1)  # 次日收益率
                return df

            # 极值数据处理
            def _winsorize(df):
                df = df.copy()
                factor_columns = ["factor"]
                for factor in factor_columns:
                    mean = df[factor].mean()
                    sigma = df[factor].std()
                    df[factor] = df[factor].clip(mean - 3 * sigma, mean + 3 * sigma)
                return df

            # 标准数据处理
            def _standardlize(df):
                df = df.copy()
                factor_columns = ["factor"]
                for factor in factor_columns:
                    mean = df[factor].mean()
                    sigma = df[factor].std()
                    df[factor] = (df[factor] - mean) / sigma
                return df

            assignment_targets, assignment_value = bigexpr.parse_assignment(factor_expr)
            factor_df = continus_contract_df.groupby("instrument").apply(
                _handle_data, assignment_value=assignment_value, price_type="close")

            base_factor_df = factor_df[["date", "instrument", "close", "ret", "factor", "daily_ret_1"]]
            # 标准化，去极值处理
            if self.is_standardlize and not self.is_winsorize:
                base_factor_df = base_factor_df.groupby("date").apply(
                    lambda x: _standardlize(x)).reset_index(drop=True)
            elif self.is_winsorize and not self.is_standardlize:
                base_factor_df = base_factor_df.groupby("date").apply(
                    lambda x: _winsorize(x)).reset_index(drop=True)
            elif self.is_winsorize and self.is_standardlize:
                base_factor_df = base_factor_df.groupby("date").apply(
                    lambda x: _standardlize(_winsorize(x))).reset_index(drop=True)
            # 对数据根据时间进行过滤
            base_factor_df = base_factor_df[(base_factor_df['date']>self.start_date) & ((
                base_factor_df['date']<self.end_date))]

            # 对应用户抽取的列名
            if assignment_targets:
                for target in assignment_targets:
                    base_factor_df[target] = base_factor_df["factor"]

            # if not self.is_roll_rebalance:
            #     td = D.trading_days(
            #         start_date=base_factor_df.date.min().strftime("%Y-%m-%d"))
            #     rebalance_days = td[:: self.rabalance_period]  # 调仓期
            #     rebalance_days_df = pd.DataFrame(
            #         {"date": rebalance_days["date"], "ix": range(len(rebalance_days))})
            #     rebalance_days_df.index = range(len(rebalance_days_df))
            #     merge_df = pd.merge(
            #         base_factor_df, rebalance_days_df, on="date", how="inner")
            # else:
            #     merge_df = base_factor_df
            td = D.trading_days(start_date=base_factor_df.date.min().strftime('%Y-%m-%d'))
            rebalance_days = td[::self.rabalance_period]  # 调仓期
            rebalance_days_df = pd.DataFrame({'date': rebalance_days['date'], 'ix': range(len(rebalance_days))})
            rebalance_days_df.index = range(len(rebalance_days_df))
            merge_df = pd.merge(base_factor_df, rebalance_days_df, on='date', how='inner')

            # 将因子名或因子表达式抽取出来做展示处理
            factor_name = assignment_targets[0] if assignment_targets else assignment_value
            self.log.info("data_processing process %.3fs" % (time.time() - start_time))
            return merge_df, base_factor_df, factor_name
        
        def ic_processing(self, merge_df, factor_name):
            start_time = time.time()
            self.log.info("ic_processing start ...")

            def _cal_IC(df, method="Rank_IC"):
                """计算IC系数"""
                from scipy.stats import pearsonr, spearmanr

                df = df.dropna()
                if df.shape[0] == 0:
                    return np.nan

                if method == "Rank_IC":
                    return spearmanr(df["factor"], df["ret"])[0]
                if method == "IC":
                    return pearsonr(df["factor"], df["ret"])[0]

            ic = merge_df.groupby("date").apply(_cal_IC, method=self.ic_method)
            # if self.is_roll_rebalance:
            #     ic = ic.rolling(self.rabalance_period).mean()[
            #         ic.index[:: self.rabalance_period]]

            # ic相关指标
            ic_mean = np.round(ic.mean(), 4)
            ic_std = np.round(ic.std(), 4)
            ic_ir = np.round(ic_mean / ic_std, 4)
            positive_ic_cnt = len(ic[ic > 0])
            negative_ic_cnt = len(ic[ic < 0])
            ic_skew = np.round(ic.skew(), 4)
            ic_kurt = np.round(ic.kurt(), 4)

            # IC指标展示
            results = {
                "stats": {
                    "ic_mean": ic_mean,
                    "ic_std": ic_std,
                    "ic_ir": ic_ir,
                    "positive_ic_cnt": positive_ic_cnt,
                    "negative_ic_cnt": negative_ic_cnt,
                    "ic_skew": ic_skew,
                    "ic_kurt": ic_kurt,
                },
                "title": f"{factor_name}: IC分析",
            }

            ic.name = "ic"
            ic_df = ic.to_frame()
            ic_df["ic_cumsum"] = ic_df["ic"].cumsum()
            self.log.info("ic_processing process  %.3fs" % (time.time() - start_time))
            return ic_df, results

        def ols_stats_processing(self, merge_df, factor_name):
            start_time = time.time()
            self.log.info("ols_stats_processing start ...")

            def _get_model_stats(X, y):
                from pyfinance import ols

                model = ols.OLS(y=y, x=X)
                return [model.beta, model.tstat_beta, model.pvalue_beta, model.se_beta]

            ols_stats = merge_df.dropna().groupby("date").apply(
                lambda df: _get_model_stats(df[["factor"]], df["ret"]))
            ols_stats_df = pd.DataFrame(ols_stats)
            ols_stats_df.rename(columns={0: "ols_result"}, inplace=True)
            ols_stats_df["beta"] = ols_stats_df["ols_result"].apply(lambda x: x[0])
            ols_stats_df["tstat_beta"] = ols_stats_df["ols_result"].apply(lambda x: x[1])
            ols_stats_df["pvalue_beta"] = ols_stats_df["ols_result"].apply(lambda x: x[2])
            ols_stats_df["se_beta"] = ols_stats_df["ols_result"].apply(lambda x: x[3])
            ols_stats_df = ols_stats_df[["beta", "tstat_beta", "pvalue_beta", "se_beta"]]

            # if self.is_roll_rebalance:
            #     ols_stats_df = ols_stats_df.rolling(self.rabalance_period).mean(
            #     ).loc[ols_stats_df.index[:: self.rabalance_period]]

            roll_beta_period = 12
            ols_stats_df["cum_beta"] = ols_stats_df["beta"].cumsum()
            ols_stats_df["roll_beta"] = ols_stats_df["beta"].rolling(
                roll_beta_period).mean()

            # 因子收益率数据加工
            ols_stats_df["abs_t_value"] = ols_stats_df["tstat_beta"].abs()
            # 相应指标
            beta_mean = np.round(ols_stats_df["beta"].mean(), 4)
            beta_std = np.round(ols_stats_df["beta"].std(), 4)
            positive_beta_ratio = np.round(
                len(ols_stats_df["beta"][ols_stats_df["beta"] > 0]) / len(ols_stats_df), 4) * 100
            abs_t_mean = np.round(ols_stats_df["abs_t_value"].mean(), 4)
            abs_t_value_over_two_ratio = np.round(len(
                ols_stats_df["abs_t_value"][ols_stats_df["abs_t_value"] > 2]) / len(ols_stats_df["abs_t_value"]), 4)
            p_value_less_ratio = np.round(len(
                ols_stats_df["pvalue_beta"][ols_stats_df["pvalue_beta"] < 0.05]) / len(ols_stats_df["pvalue_beta"]), 4)

            results = {
                "stats": {
                    "beta_mean": beta_mean,
                    "beta_std": beta_std,
                    "positive_beta_ratio": positive_beta_ratio,
                    "abs_t_mean": abs_t_mean,
                    "abs_t_value_over_two_ratio": abs_t_value_over_two_ratio,
                    "p_value_less_ratio": p_value_less_ratio,
                },
                "title": f"{factor_name}: 因子收益率分析",
            }
            self.log.info("ols_stats_processing process  %.3fs" %
                          (time.time() - start_time))
            return ols_stats_df, results

        def group_processing(self, merge_df, base_factor_df, factor_name):
            start_time = time.time()
            self.log.info("group_processing start ...")

            def _fill_ix_na(df):
                df['rebalance_index'] = df['ix'].fillna(method='ffill')
                return df

            def _unify_factor(tmp):
                """因子以调仓期首日因子为准"""
                tmp['factor'] = list(tmp['factor'])[0]
                return tmp

            def _cut_box(df, quantile_num=5):
                if df.factor.isnull().sum() == len(df):  # 因子值全是nan的话
                    df["factor_group"] = [np.nan] * len(df)
                else:
                    labels = [str(i) for i in range(quantile_num)]
                    df["factor_group"] = pd.qcut(
                        df["factor"], quantile_num, labels=labels)  # 升序排序，分成5组
                return df

            # 计算绩效指标
            def _get_stats(results, col_name):
                import empyrical

                return_ratio = np.round(
                    empyrical.cum_returns_final(results[col_name]), 4)
                annual_return_ratio = np.round(
                    empyrical.annual_return(results[col_name]), 4)
                sharp_ratio = np.round(empyrical.sharpe_ratio(
                    results[col_name], 0.035/252), 4)
                return_volatility = np.round(
                    empyrical.annual_volatility(results[col_name]), 4)
                max_drawdown = np.round(empyrical.max_drawdown(results[col_name]), 4)

                res = {'收益率': [return_ratio]}
                date_dict = {1: "1日", 5: "1周", 22: "1月"}
                for n in [1, 5, 22]:
                    res['近{}收益率'.format(date_dict[n])] = np.round(results[col_name.replace('ret', 'pv')][-1] / results[col_name.replace('ret', 'pv')][-(n+1)] -1, 4)
                res.update({
                '年化收益率': [annual_return_ratio],
                '夏普比率': [sharp_ratio],
                '收益波动率': [return_volatility],
                '最大回撤': [max_drawdown]})
                return pd.DataFrame(res)

            merge_df2 = pd.merge(base_factor_df[['date', 'instrument', 'factor', 'daily_ret_1']],
                                 merge_df[['date', 'instrument', 'ix']], how='left', on=['date', 'instrument'])

            merge_df2 = merge_df2.groupby('instrument').apply(_fill_ix_na)
            unify_factor_df = merge_df2.groupby(['rebalance_index', 'instrument']).apply(_unify_factor)

            group_df = unify_factor_df.groupby("date").apply(_cut_box, quantile_num=self.quantile_num)
            
            # 计算每组每天的收益率
            result = group_df[['date', 'factor_group', 'daily_ret_1', 'rebalance_index', 'ix']].groupby(
                ['factor_group', 'date']).mean().reset_index()
            # 调仓日的收益率需要扣除交易成本
            result['daily_ret_1'] -= (self.buy_commission_rate + self.sell_commission_rate) * \
                np.where(result['ix'].isna(), 0, 1)

            result_table = result.pivot(
                values="daily_ret_1", columns="factor_group", index="date")
            
            result_table.rename(
                columns={i: 'top%s_ret' % i for i in result_table.columns}, inplace=True)

            # if self.is_roll_rebalance:
            #     result_table = result_table.rolling(self.rabalance_period).mean(
            #     ).loc[result_table.index[:: self.rabalance_period]]

            small_quantile_name = result_table.columns.min()
            big_quantile_name = result_table.columns.max()
            result_table["LS_ret"] = result_table[small_quantile_name] - result_table[big_quantile_name]
            # 移除na值,防止收益计算为难
            result_table.dropna(inplace=True)

            for i in result_table.columns:
                col_name = i.split("_")[0] + "_" + "pv"
                result_table[col_name] = (1 + result_table[i]).cumprod()

            small_quantile_perf = _get_stats(result_table, small_quantile_name)
            big_quantile_perf = _get_stats(result_table, big_quantile_name)
            df = pd.concat([small_quantile_perf, big_quantile_perf])
            df.index = [small_quantile_name, big_quantile_name]
            results = {
                "stats": df.T.to_dict(),
                "title": f"{factor_name}: 因子绩效分析",
            }
            self.log.info("group_processing process  %.3fs" %
                          (time.time() - start_time))
            return result_table, results

        def process(self, continus_contract_df, factor_exprs):
            factor_data = []
            performance_data = []
            # 更新结束日期
            is_live_run = T.live_run_param("trading_date", None) is not None
            if is_live_run:
                self.end_date = T.live_run_param("trading_date", "trading_date")
            # 进行因子计算
            for factor_expr in factor_exprs:
                # continus_contract_df = self.load_continus_instrument(df)
                merge_df, base_factor_df, factor_name = self.data_processing(
                    continus_contract_df, factor_expr)
         
                ic_data = self.ic_processing(merge_df, factor_name)
                ols_data = self.ols_stats_processing(merge_df, factor_name)
                group_data = self.group_processing(merge_df, base_factor_df, factor_name)

                # 保存因子相关信息
                options_data = {
                    "start_date": self.start_date,
                    "end_date": self.end_date,
                    "rabalance_period": self.rabalance_period,
                    "buy_commission_rate": self.buy_commission_rate,
                    "sell_commission_rate": self.sell_commission_rate,
                    # "is_roll_rebalance": self.is_roll_rebalance,
                    "ic_method": self.ic_method,
                    "quantile_num": self.quantile_num,
                }
                result = {
                    "summary": {"IC": ic_data[1], "FactorReturns": ols_data[1], "QuantileReturns": group_data[1]},
                    "data": {"IC": ic_data[0], "FactorReturns": ols_data[0], "QuantileReturns": group_data[0]},
                    "options": options_data,
                }
                factor_data.append(base_factor_df)
                performance_data.append(result)

            return factor_data, performance_data
        
#     print(input_2.read())
    df = input_1.read()
    factor_exprs = input_2.read()
    log = BigLogger('FuturesPerformance')
    fp = FuturesPerformance(log, start_date, end_date, rabalance_period, buy_commission_rate, sell_commission_rate, 
                            ic_method, quantile_num, is_standardlize, is_winsorize)
    data_1, data_2 = fp.process(df, factor_exprs)
    data_1 = DataSource.write_pickle(data_1)
    data_2 = DataSource.write_pickle(data_2)
#     data_1 = DataSource('994493c3e5164362b7dec1793d6a466aT').read()
#     data_1 = DataSource.write_pickle(data_1)

    return Outputs(data_1=data_1, data_2=data_2, data_3=None)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m2_post_run_bigquant_run(outputs):
    from jinja2 import Template
    from biglearning.module2.common.utils import display_html
    
    class RenderHtml:
        ic_stats_template = """
        <div style="width:100%;text-align:center;color:#333333;margin-bottom:16px;font-size:12px;"><h2>{{ title }}</h2></div>
        <div class='kpicontainer'>
            <ul class='kpi'>
                <li><span class='title'>IC均值</span><span class='value'>{{ stats.ic_mean }}</span></li>
                <li><span class='title'>IC标准差</span><span class='value'>{{ stats.ic_std }}</span></li>
                <li><span class='title'>ICIR</span><span class='value'>{{ stats.ic_ir }}</span></li>
                <li><span class='title'>IC正值次数</span><span class='value'>{{ stats.positive_ic_cnt }}次</span></li>
                <li><span class='title'>IC负值次数</span><span class='value'>{{ stats.negative_ic_cnt }}次</span></li>
                <li><span class='title'>IC偏度</span><span class='value'>{{ stats.ic_skew }}</span></li>
                <li><span class='title'>IC峰度</span><span class='value'>{{ stats.ic_kurt }}</span></li>
            </ul>
        </div>
        """
        ols_stats_template = """
        <div style="width:100%;text-align:center;color:#333333;margin-bottom:16px;font-size:12px;"><h2>{{ title }}</h2></div>
        <div class='kpicontainer'>
            <ul class='kpi'>
                <li><span class='title'>因子收益均值</span><span class='value'>{{ stats.beta_mean }}</span></li>
                <li><span class='title'>因子收益标准差</span><span class='value'>{{ stats.beta_std }}</span></li>
                <li><span class='title'>因子收益为正比率</span><span class='value'>{{ stats.positive_beta_ratio }}%</span></li>
                <li><span class='title'>t值绝对值的均值</span><span class='value'>{{ stats.abs_t_mean }}</span></li>
                <li><span class='title'>t值绝对值大于2的比率</span><span class='value'>{{ stats.abs_t_value_over_two_ratio }}</span></li>
                <li><span class='title'>因子收益t检验p值小于0.05的比率</span><span class='value'>{{ stats.p_value_less_ratio }}</span></li>
            </ul>
        </div>
        """
        group_stats_template = """
        <div style="width:100%;text-align:center;color:#333333;margin-bottom:16px;font-size:12px;"><h2>{{ title }}</h2></div>
        <div class='kpicontainer'>
            <ul class='kpi'>
                <li><span class='title'>&nbsp;</span>
                    {% for k in stats%}
                        <span class='value'>{{ k }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>收益率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].收益率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>近1日收益率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].近1日收益率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>近1周收益率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].近1周收益率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>近1月收益率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].近1月收益率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>年化收益率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].年化收益率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>夏普比率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].夏普比率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>收益波动率</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].收益波动率 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
                <li><span class='title'>最大回撤</span>
                    {% for k in stats%}
                        <span class='value'>{{ (stats[k].最大回撤 | string)[0:10] }}</span>
                    {% endfor %}
                </li>
             </ul>
        </div>
        """

        def __init__(self, ic_data, ic_summary, factor_returns_data, factor_returns_summary, quantile_returns_data, quantile_returns_summary):
            self.ic_df = ic_data
            self.ic_results = ic_summary
            self.ols_stats_df = factor_returns_data
            self.ols_stats_results = factor_returns_summary
            self.group_df = quantile_returns_data
            self.group_df_results = quantile_returns_summary

        def render_results(self, stats_template, results):
            """ 展示模板信息 """

            def render(stats_template, results):
                html = Template(stats_template).render(stats=results["stats"], title=results["title"])
                display_html(html)

            render(stats_template, results)

        def show_ic(self):
            self.render_results(self.ic_stats_template, self.ic_results)
            T.plot(
                self.ic_df,
                title="IC分析",
                panes=[["ic", "40%"], ["ic_cumsum", "20%"]],
                # height=500，设置高度为500
                options={
                    "chart": {"height": 500},
                    # 设置颜色
                    "series": [
                        {
                            "name": "ic",
                            "color": "#8085e8",
                            "type": "column",
                            "yAxis": 0,
                        },
                        {
                            "name": "ic_cumsum",
                            "color": "#8d4653",
                            "type": "spline",
                            "yAxis": 0,
                        },
                    ],
                },
            )

        def show_ols(self):
            self.render_results(self.ols_stats_template, self.ols_stats_results)
            T.plot(
                self.ols_stats_df[["beta", "cum_beta", "roll_beta"]],
                title="因子收益率",
                # high、low显示在第一栏，高度40%，open、close显示在第二栏，其他的在最后一栏
                panes=[["beta", "cum_beta", "40%"], ["roll_beta", "20%"]],
                # height=500，设置高度为500
                options={
                    "chart": {"height": 500},
                    # 设置颜色
                    "series": [
                        {
                            "name": "beta",
                            "color": "#8085e8",
                            "type": "column",
                            "yAxis": 0,
                        },
                        {
                            "name": "cum_beta",
                            "color": "#8d4653",
                            "type": "column",
                            "yAxis": 0,
                        },
                        {
                            "name": "roll_beta",
                            "color": "#91e8e1",
                            "type": "spline",
                            "yAxis": 1,
                        },
                    ],
                },
            )

        def show_group(self):
            self.render_results(self.group_stats_template, self.group_df_results)
            T.plot(self.group_df[[i for i in self.group_df.columns if "_pv" in i]])
        
        def show(self):
            self.show_ic()
            self.show_ols()
            self.show_group()
    
    # 读取 IC,FactorReturns,QuantileReturns用作展示
    performance_data = outputs.data_2.read()
    for data in performance_data:
        ic_data = data["data"]["IC"]
        factor_returns_data = data["data"]["FactorReturns"]
        quantile_returns_data = data["data"]["QuantileReturns"]
        ic_summary = data["summary"]["IC"]
        factor_returns_summary = data["summary"]["FactorReturns"]
        quantile_returns_summary = data["summary"]["QuantileReturns"]
        renderhtml = RenderHtml(ic_data, ic_summary, factor_returns_data, factor_returns_summary, quantile_returns_data, quantile_returns_summary)
        renderhtml.show()
    return outputs


m14 = M.input_features.v1(
    features="""Trend_Strength
ret_skew
ret_kurt""",
    m_cached=False
)

m16 = M.input_features.v1(
    features="""_last_price = close.iloc[-1] 
close = _last_price  ##因子分析必须

## 动量类因子
# 趋势强度
_p1 = close.iloc[-1] - close.iloc[0] #一日收盘价差值
_p2 = abs(close-close.shift(1))[1:].sum() #今昨两日收盘价分钟序列差值求和
Trend_Strength = _p1 / _p2 #日内价格位移与路程之比

## 收益率分布因子
# 高频偏度和峰度
_ret_log = log(close.pct_change().fillna(method='bfill') + 1) #对数收益率
ret_skew = _ret_log.skew() #收益率偏度
ret_kurt = _ret_log.kurt() #收益率峰度"""
)

m4 = M.datahub_load_datasource.v1(
    table='index_constituent_CN_STOCK_A',
    start_date='2020-05-01',
    end_date='2020-12-01',
    instruments="""# #号开始的表示注释，注释需单独一行
# 每行一条
""",
    fields="""# #号开始的表示注释，注释需单独一行
# 每行一条
"""
)

m3 = M.filter.v3(
    input_data=m4.data,
    expr='in_csi300==1',
    output_left_data=False
)

m5 = M.cached.v3(
    input_1=m3.data,
    run=m5_run_bigquant_run,
    post_run=m5_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m15 = M.feature_extractor_1m.v1(
    instruments=m5.data_1,
    features=m16.data,
    start_date='',
    end_date='',
    before_start_days=0,
    workers=4,
    parallel_mode='集群',
    table_1m='level2_bar1m_CN_STOCK_A'
)

m20 = M.cached.v3(
    input_1=m15.data,
    run=m20_run_bigquant_run,
    post_run=m20_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m2 = M.cached.v3(
    input_1=m20.data_1,
    input_2=m14.data,
    run=m2_run_bigquant_run,
    post_run=m2_post_run_bigquant_run,
    input_ports='input_1, input_2',
    params="""{
    'start_date': '2020-01-01',
    'end_date': '2021-05-15',
    'rabalance_period': 5,
    'buy_commission_rate': 0.0005,
    'sell_commission_rate': 0.0005,
    'ic_method': 'Rank_IC',
    'quantile_num': 5,
    'is_standardlize': True,
    'is_winsorize': True
}""",
    output_ports='data_1, data_2'
)

m13 = M.factorlens_preservation.v1(
    factors_df=m2.data_1,
    performance_data=m2.data_2,
    features=m14.data,
    factor_column='[\'Trend_Strength\', \'ret_skew\', \'ret_kurt\']',
    factor_name='hf_Trend_Strength, hf_ret_skew, hf_ret_kurt',
    m_cached=False
)

[2021-05-19 11:04:40.866775] INFO: moduleinvoker: input_features.v1 开始运行..

[2021-05-19 11:04:41.077065] INFO: moduleinvoker: input_features.v1 运行完成[0.210296s].

[2021-05-19 11:04:41.087290] INFO: moduleinvoker: instruments.v2 开始运行..

[2021-05-19 11:04:41.135430] INFO: moduleinvoker: instruments.v2 运行完成[0.048138s].

[2021-05-19 11:04:41.148096] INFO: moduleinvoker: feature_extractor_1m.v1 开始运行..

[2021-05-19 11:04:41.176454] INFO: 高频特征抽取-分钟到日频: 测试模式运行, ['B0000.DCE', 'FU0000.SHF', 'SC0000.INE']

[2021-05-19 11:04:41.177882] INFO: fe1m_utils: extract chunk 3 instruments, 8 features ..

[2021-05-19 11:04:41.179549] INFO: fe1m_utils: extract chunk 3 instruments, n_jobs=30=(20+40)/2, 并行=False ..

[2021-05-19 11:04:44.674364] INFO: fe1m_utils: extracted chunk 3/3 instruments, (246, 6).

[2021-05-19 11:04:44.747785] WARNING: 高频特征抽取-分钟到日频: no data found for {'PK0000.CZC', 'C0000.DCE', 'RR0000.DCE', 'M0000.DCE', 'SN0000.SHF', 'SS0000.SHF', 'JD0000.DCE', 'AG0000.SHF', 'TA0000.CZC', 'JM0000.DCE', 'PG0000.DCE', 'SF0000.CZC', 'SM0000.CZC', 'ZN0000.SHF', 'I0000.DCE', 'V0000.DCE', 'FG0000.CZC', 'BC0000.INE', 'LH0000.DCE', 'UR0000.CZC', 'P0000.DCE', 'SR0000.CZC', 'BU0000.SHF', 'CY0000.CZC', 'PB0000.SHF', 'CF0000.CZC', 'Y0000.DCE', 'SA0000.CZC', 'A0000.DCE', 'RU0000.SHF', 'SP0000.SHF', 'NI0000.SHF', 'CJ0000.CZC', 'CS0000.DCE', 'AP0000.CZC', 'NR0000.INE', 'EG0000.DCE', 'J0000.DCE', 'HC0000.SHF', 'PF0000.CZC', 'MA0000.CZC', 'ZC0000.CZC', 'OI0000.CZC', 'AU0000.SHF', 'RM0000.CZC', 'EB0000.DCE', 'CU0000.SHF', 'PP0000.DCE', 'RB0000.SHF'}

[2021-05-19 11:04:44.749139] INFO: 高频特征抽取-分钟到日频: extracted 3/52 instruments, (246, 6)

[2021-05-19 11:04:44.753265] INFO: moduleinvoker: feature_extractor_1m.v1 运行完成[3.605205s].