克隆策略

In [9]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
from datetime import datetime
import time
import bigexpr

 

class FuturesPerformance:
    def __init__(self,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.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_name):
        # 表达式抽取
        start_time = time.time()


        def _handle_data(df, factor_name, price_type):
            # 计算当期因子和未来一段时间收益率
            # df["factor"] = df["close"] / df["close"].shift(44) - 1  # 构建因子
            df["factor"] = df[factor_name]

            # 持有期收益率
            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
 
        factor_df_with_ret = continus_contract_df.groupby("instrument").apply(_handle_data, factor_name=factor_name, price_type="close")
 
        base_factor_df = factor_df_with_ret[["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))]
        # 对应用户抽取的列名
#         print("base_factor_df1=",self.start_date,self.end_date,base_factor_df)
        base_factor_df[factor_name] = base_factor_df["factor"]
        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')

        # 将因子名或因子表达式抽取出来做展示处理
        
        return merge_df, base_factor_df, factor_name

    def ic_processing(self, merge_df, factor_name):
        start_time = time.time()
        
        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)
        # 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()
       
        return ic_df, results

    def ols_stats_processing(self, merge_df, factor_name):
        start_time = time.time()
        
        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"]]

        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}: 因子收益率分析",
        }
        
        return ols_stats_df, results

    def group_processing(self, merge_df, base_factor_df, factor_name):
        start_time = time.time()
        

        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)
       
        small_quantile_name = result_table.columns.min()
        big_quantile_name = result_table.columns.max()
        long_short_name = 'LS_ret'
        result_table["LS_ret"] = (result_table[small_quantile_name] - result_table[big_quantile_name])/2
        # 移除na值, 防止收益计算为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)
        long_short_perf = _get_stats(result_table,long_short_name )
        df = pd.concat([small_quantile_perf, big_quantile_perf,long_short_perf])
        df.index = [small_quantile_name, big_quantile_name,long_short_name]
 
        results = {
            "stats": df.T.to_dict(),
            "title": f"{factor_name}: 因子绩效分析",
        }
 
        
        return result_table, results

    def process(self, continus_contract_df, factors_name):
        factor_data = []
        performance_data = []
        # 进行因子计算
        for factor_name in factors_name:
            if factor_name.startswith("_"):
                continue
            merge_df, base_factor_df, factor_name = self.data_processing(continus_contract_df, factor_name)
            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,
                "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
        
def m6_run_bigquant_run(input_1, input_2, input_3, rabalance_period, buy_commission_rate, sell_commission_rate, 
                 ic_method, quantile_num, is_standardlize, is_winsorize):
        
    start_date, end_date, instruments = input_1.read()["start_date"], input_1.read()["end_date"], input_1.read()["instruments"]
    df_factor = input_2.read()
    factors_name = input_3.read()
    md = DataSource("bar1d_CN_FUTURE").read(instruments=instruments, start_date=start_date, end_date=end_date, fields=["close"])
 
    continus_contract_df = df_factor.merge(md, on=["instrument", "date"], how="left")

    
    fp = FuturesPerformance( 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(continus_contract_df, factors_name)
    res = {}
    for factor in factors_name:
        fact_explain = factor.split("=")
        if len(fact_explain) > 1:
            factor_expr = fact_explain[1].strip()
        factor_name = fact_explain[0].strip()
        res[factor_name] = {}
        options = data_2[0]["options"]
        summary = data_2[0]["summary"]
        metrics = {}
        metrics["IC均值"] = summary["IC"]["stats"]["ic_mean"]
        metrics["IC_IR"] = summary["IC"]["stats"]["ic_ir"]
        metrics["近1日收益率"] = summary["QuantileReturns"]["stats"]["top0_ret"]["近1日收益率"]
        metrics["近1周收益率"] = summary["QuantileReturns"]["stats"]["top0_ret"]["近1周收益率"]
        metrics["近1月收益率"] = summary["QuantileReturns"]["stats"]["top0_ret"]["近1月收益率"]
        datasource = data_1[0][["date", "instrument", factor_name]]
        column_name = factor_name
        expr = factor_expr if len(fact_explain) > 1 else ""
        for info in [{"options": options}, {"metrics": metrics}, {"datasource": datasource}, {"column_name": column_name}, {"expr": expr}]:
            res[factor_name].update(info)
    
    data_1 = DataSource.write_pickle(res)
    data_2 = DataSource.write_pickle(data_2)
    return Outputs(data_1=data_1, data_2=data_2, data_3=None)
# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m6_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


m1 = M.input_features.v1(
    features="""factor=np.corrcoef(close.pct_change().fillna(0),amount)[0][1]

"""
)

m7 = M.instruments.v2(
    start_date='2020-01-02',
    end_date=T.live_run_param('trading_date', '2021-10-12'),
    market='CN_FUTURE',
    instrument_list="""A8888.DCE
AG8888.SHF
AL8888.SHF
AU8888.SHF
B8888.DCE
BB8888.DCE
BU8888.SHF
# C88.DCE
# CF88.CZC
# CS88.DCE
# CU88.SHF
# FB88.DCE
# FG88.CZC
# FU88.SHF
# HC88.SHF
# I88.DCE
# J88.DCE
# JD88.DCE
# JM88.DCE
# JR88.CZC
# L88.DCE
# LR88.CZC
# M88.DCE
# MA88.CZC
# OI88.CZC
# P88.DCE
# PB88.SHF
# PM88.CZC
# PP88.DCE
# RB88.SHF
# RM88.CZC 
# RU88.SHF
# SF88.CZC
# SM88.CZC
# SR88.CZC
# TA88.CZC
# TF88.CFX
# V88.DCE
# Y88.DCE
# ZN88.SHF
# NI88.SHF
# SN88.SHF
# ZC88.CZC
# CY88.CZC
# AP88.CZC
# SC88.INE
# SP88.SHF
# EG88.DCE
# EB88.DCE
# SA88.CZC
# PG88.DCE
# LU88.INE
# PF88.CZC""",
    max_count=0
)

m14 = M.feature_extractor_1m.v2(
    instruments=m7.data,
    features=m1.data,
    start_date='',
    end_date='',
    before_start_days=60,
    workers=1,
    parallel_mode='集群',
    table_1m='bar1m_CN_FUTURE'
)

m2 = M.input_features.v1(
    features="""factor

"""
)

m6 = M.cached.v3(
    input_1=m7.data,
    input_2=m14.data,
    input_3=m2.data,
    run=m6_run_bigquant_run,
    post_run=m6_post_run_bigquant_run,
    input_ports='input_1, input_2, input_3',
    params="""{
    '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
}""",
    output_ports='data_1, data_2',
    m_cached=False
)

m3 = M.factorlens_preservation.v1(
    factors_info=m6.data_1
)

[2021-10-18 13:34:08.114232] INFO: moduleinvoker: input_features.v1 开始运行..

[2021-10-18 13:34:08.124009] INFO: moduleinvoker: 命中缓存

[2021-10-18 13:34:08.125448] INFO: moduleinvoker: input_features.v1 运行完成[0.011225s].

[2021-10-18 13:34:08.130303] INFO: moduleinvoker: instruments.v2 开始运行..

[2021-10-18 13:34:08.142033] INFO: moduleinvoker: 命中缓存

[2021-10-18 13:34:08.143398] INFO: moduleinvoker: instruments.v2 运行完成[0.013092s].

[2021-10-18 13:34:08.151833] INFO: moduleinvoker: feature_extractor_1m.v2 开始运行..

[2021-10-18 13:34:08.160994] INFO: moduleinvoker: 命中缓存

[2021-10-18 13:34:08.162192] INFO: moduleinvoker: feature_extractor_1m.v2 运行完成[0.010357s].

[2021-10-18 13:34:08.165784] INFO: moduleinvoker: input_features.v1 开始运行..

[2021-10-18 13:34:08.175878] INFO: moduleinvoker: 命中缓存

[2021-10-18 13:34:08.177249] INFO: moduleinvoker: input_features.v1 运行完成[0.011482s].

[2021-10-18 13:34:08.209458] INFO: moduleinvoker: cached.v3 开始运行..

[2021-10-18 13:34:12.113658] INFO: moduleinvoker: cached.v3 运行完成[3.904214s].

[2021-10-18 13:34:12.120012] INFO: moduleinvoker: factorlens_preservation.v1 开始运行..

[2021-10-18 13:34:12.131473] INFO: 保存因子: 开始保存因子: factor

[2021-10-18 13:34:12.132510] INFO: 保存因子: factor数据格式无误，可以提交任务

[2021-10-18 13:34:12.169582] INFO: moduleinvoker: factorlens_preservation.v1 运行完成[0.049566s].

factor: IC分析

IC均值-0.1071
IC标准差0.464
ICIR-0.2308
IC正值次数8次
IC负值次数11次
IC偏度0.3872
IC峰度-0.3103

factor: 因子收益率分析

因子收益均值-0.0058
因子收益标准差0.025
因子收益为正比率36.84%
t值绝对值的均值0.9998
t值绝对值大于2的比率0.1579
因子收益t检验p值小于0.05的比率0.0526

factor: 因子绩效分析

top0_ret top4_ret LS_ret
收益率 0.4287 0.0681 0.1017
近1日收益率 0.0024 -0.0059 0.0041
近1周收益率 0.0117 0.0049 0.0032
近1月收益率 -0.0039 -0.0321 0.0142
年化收益率 0.2362 0.0399 0.0593
夏普比率 0.9733 0.172 0.2179
收益波动率 0.2031 0.3157 0.1685
最大回撤 -0.1673 -0.3389 -0.1759