复制链接

克隆策略

In [ ]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m2_run_bigquant_run(input_1, start_date,end_date):
    # 示例代码如下。在这里编写您的代码
    #from datetime import datetime
    #ins=input_1.read_pickle()['instruments']
    #start_date=input_1.read_pickle()['start_date']
    #end_date=input_1.read_pickle()['end_date']
    #start_date_dt = datetime.strptime(start_date, '%Y-%m-%d')
    #end_date_dt = datetime.strptime(end_date, '%Y-%m-%d')
    
    fund_info = DataSource('basic_info_CN_FUND').read()
    #fund_info_0 = fund_info[fund_info['type'] == 'ETF']

    data_1 = DataSource.write_df(fund_info)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

# 后处理函数，可选。输入是主函数的输出，可以在这里对数据做处理，或者返回更友好的outputs数据格式。此函数输出不会被缓存。
def m2_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):
    # 示例代码如下。在这里编写您的代码
    from datetime import datetime
    ins=input_1.read_pickle()['instruments']
    start_date=input_1.read_pickle()['start_date']
    end_date=input_1.read_pickle()['end_date']
    start_date_dt = datetime.strptime(start_date, '%Y-%m-%d')
    end_date_dt = datetime.strptime(end_date, '%Y-%m-%d')
    
    fund_info_0 = DataSource.read_df(input_2)
    fund_info1 = fund_info_0[(fund_info_0['delist_date'] >= end_date_dt) & (fund_info_0['list_date'] <= start_date_dt)]
    fund_info2 = fund_info_0[fund_info_0['delist_date'].isnull() & (fund_info_0['list_date'] <= start_date_dt)]
    ins1 = fund_info1['instrument'].to_list()       
    ins2 = fund_info2['instrument'].to_list()       
    ins1.extend(ins2)
    df=DataSource('bar1d_CN_FUND').read(ins1,start_date=start_date,end_date=end_date)
    data_1 = DataSource.write_df(df)
    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 m3_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = DataSource.read_df(input_1)
    df['close'] = df['close'] * df['adjust_factor']
    df = df.sort_values(['instrument', 'date'])
    first_instrument = df.iloc[0]['instrument']
    for key, group in df.groupby('instrument'):
        group['return_0'] = group['close'] / group['close'].shift(1) - 1
        if key == first_instrument:
            group_all = group
        else:
            group_all = pd.concat([group_all, group])
    group_all = group_all.dropna()
    #df['cum_return'] = (df['return_0'] + 1).cumprod() - 1
    data_1 = DataSource.write_df(group_all)
    #data_2 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m6_run_bigquant_run(input_1):
    # 示例代码如下。在这里编写您的代码
    #from datetime import datetime
    #ins=input_1.read_pickle()['instruments']
    #start_date=input_1.read_pickle()['start_date']
    #end_date=input_1.read_pickle()['end_date']
    #start_date_dt = datetime.strptime(start_date, '%Y-%m-%d')
    #end_date_dt = datetime.strptime(end_date, '%Y-%m-%d')
    
    #if len(ins) == 0:
    fund_info = DataSource('basic_info_CN_MUTFUND').read()
        #fund_info_0 = fund_info[fund_info['etf_lof'] == 'ETF']
    data_1 = DataSource.write_df(fund_info)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m19_run_bigquant_run(input_1, input_2):
    # 示例代码如下。在这里编写您的代码
    from datetime import datetime
    ins=input_1.read_pickle()['instruments']
    start_date=input_1.read_pickle()['start_date']
    end_date=input_1.read_pickle()['end_date']
    start_date_dt = datetime.strptime(start_date, '%Y-%m-%d')
    end_date_dt = datetime.strptime(end_date, '%Y-%m-%d')
    fund_info_0 = DataSource.read_df(input_2)
    
    fund_info_delist_date = fund_info_0[fund_info_0['delist_date'].notnull()]
    fund_info_delist_date1 = fund_info_delist_date[(fund_info_delist_date['delist_date'] >= end_date_dt) & (fund_info_delist_date['list_date'] <= start_date_dt)]
    ins_delist_date1 = fund_info_delist_date1['instrument'].to_list()
    fund_info_delist_date2 = fund_info_0[fund_info_0['delist_date'].isnull() & (fund_info_0['list_date'] <= start_date_dt)]
    ins_delist_date2 = fund_info_delist_date2['instrument'].to_list()
    fund_info_expire_date = fund_info_0[fund_info_0['expire_date'].notnull()]
    fund_info_expire_date1 = fund_info_expire_date[(fund_info_expire_date['expire_date'] >= end_date_dt) & (fund_info_expire_date['establish_date'] <= start_date_dt)]
    ins_expire_date1 = fund_info_expire_date1['instrument'].to_list()
    fund_info_expire_date2 = fund_info_0[fund_info_0['expire_date'].isnull() & (fund_info_0['establish_date'] <= start_date_dt)]
    ins_expire_date2 = fund_info_expire_date2['instrument'].to_list()
    ins1 = ins_delist_date1 + ins_delist_date2 + ins_expire_date1 + ins_expire_date2        
    df=DataSource('history_nav_CN_MUTFUND').read(ins1,start_date=start_date,end_date=end_date)
    data_1 = DataSource.write_df(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m28_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = DataSource.read_df(input_1)
    df = df.rename({'adjust_nav': 'close'}, axis = 1)
    df['return_0'] = df['adj_nav_chg_pct'] / 100
    '''
    df = df.sort_values(['instrument', 'date'])
    first_instrument = df.iloc[0]['instrument']
    for key, group in df.groupby('instrument'):
        group['cum_return'] = (group['return_0'] + 1).cumprod() - 1
        if key == first_instrument:
            group_all = group
        else:
            group_all = pd.concat([group_all, group])
    '''        
    data_1 = DataSource.write_df(df)
    #data_2 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m30_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    #df1 = DataSource.read_df(input_1)
    df2 = DataSource.read_df(input_2)
    df3 = DataSource.read_df(input_3)
    df = pd.concat([df2, df3])
    data_1 = DataSource.write_df(df)
    #data_2 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m36_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = DataSource.read_df(input_1)
    df = df.loc[ :,("return_0", )]
    data_1 = DataSource.write_df(df)
    #data_2 = DataSource.write_pickle(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m37_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = DataSource.read_df(input_1)
    df_columns = df.columns.to_list()
    hs300_corr = pd.DataFrame(0, index = df_columns, columns = ['hs300_corr'])
    for label, item in df.iteritems():
        hs300_corr.loc[label, 'hs300_corr'] = df['159919.ZOF'].corr(item)
    hs300_corr = hs300_corr.sort_values(by = ['hs300_corr'])
    hs300_corr1 = hs300_corr[(hs300_corr['hs300_corr'] <= 0.01) & (hs300_corr['hs300_corr'] >= - 0.01)]
    hs300_corr1_ins = hs300_corr1.index.to_list()
    hs300_corr1_ins.append('159919.ZOF')
    hs300_corr_df = df[hs300_corr1_ins]
    corr_high = hs300_corr_df.corr().applymap(lambda x: np.nan if x > 0.1 else x).isnull()
    col_all = corr_high.columns.tolist()
    del_col = []
    i = 0
    while i < len(col_all) - 1:
        ex_index = corr_high.iloc[:,i][i+1:].index[np.where(corr_high.iloc[:,i][i+1:])].tolist()
        for var in ex_index:
            col_all.remove(var)
        corr_high = corr_high.loc[col_all, col_all]
        i += 1
    col_all_corr = hs300_corr_df[col_all].corr()
    hs300_nocorr_df = hs300_corr_df[col_all]
    #print("下表为无相关性的基金的两两的相关系数，接近0表示相关性弱，接近1表示相关性强。")
    #print(col_all_corr)
    ins = hs300_nocorr_df.columns.to_list()
    df2 = DataSource("basic_info_CN_FUND").read()
    df4 = DataSource("basic_info_CN_MUTFUND").read()
    name = []
    for value in ins:
        is_named = False
        for index1, row1 in df4.iterrows():
            if value == row1['instrument']:
                name.append(row1['sec_short_name'])
                is_named = True
                break
        if not is_named:
            for index2, row2 in df2.iterrows():
                if value == row2['instrument']:
                    name.append(row2['name'])
                    is_named = True
                    break
    hs300_nocorr_df.columns = name
    data_1 = DataSource.write_df(col_all_corr)
    data_2 = DataSource.write_df(hs300_nocorr_df)
    return Outputs(data_1=data_1, data_2=data_2, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m8_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = DataSource.read_df(input_1)
    dict = DataSource.read_pickle(input_2)
    dict2 = dict.copy()
    list = df.index.to_list()
    trade_mutfund_list = []
    trade_fund_list = []
    
    for item in list:
        item_split = item.split(".")
        if item_split[1] == 'OFCN' or item_split[1] == 'OFCN2':
            trade_mutfund_list.append(item)
        elif item_split[1] == 'ZOF' or item_split[1] == 'HOF':
            trade_fund_list.append(item)
            
    dict['instruments'] = trade_mutfund_list
    dict2['instruments'] = trade_fund_list
    dict2['market'] = 'CN_FUND'
    #print(dict)
    data_1 = DataSource.write_pickle(dict2)
    data_2 = DataSource.write_pickle(dict)
    return Outputs(data_1=data_1, data_2=data_2, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m7_run_bigquant_run(input_1, input_2):
    # 示例代码如下。在这里编写您的代码
    #from datetime import datetime
    ins=input_1.read_pickle()['instruments']
    start_date=input_1.read_pickle()['start_date']
    end_date=input_1.read_pickle()['end_date']
    df=DataSource('bar1d_CN_FUND').read(ins,start_date=start_date,end_date=end_date)
    data_1 = DataSource.write_df(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m9_run_bigquant_run(input_1, input_2):
    # 示例代码如下。在这里编写您的代码
    from datetime import datetime
    ins=input_1.read_pickle()['instruments']
    start_date=input_1.read_pickle()['start_date']
    end_date=input_1.read_pickle()['end_date']
    df=DataSource('history_nav_CN_MUTFUND').read(ins,start_date=start_date,end_date=end_date)
    df['open'] = df['nav']
    df['high'] = df['nav']
    df['low'] = df['nav']
    df['close'] = df['nav']
    df['adjust_factor'] = df['adjust_nav'] / df['nav']
    df['volume'] = 1000000
    data_1 = DataSource.write_df(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m11_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df1 = DataSource.read_df(input_1)
    df2 = DataSource.read_df(input_2)
    #df3 = DataSource.read_df(input_3)
    df3 = pd.concat([df1, df2])
    #df4 = df3.reset_index()
    df5 = df3.sort_values(by = 'date')
    df5.index = range(len(df5))
    i = 0
    for name, group in df5.groupby(df5['date']):
        fund_numbers = len(group)
        weight = 1 / fund_numbers
        group['weight'] = weight
        group['date'] = name
        
        if i == 0:
            group_all = group.copy()
            first_date = name
        else:
            group_all = pd.concat([group_all, group])
        i += 1
    #group_all1 = group_all.sort_values(by = 'date')
    instrument_weight = group_all[group_all['date'] == first_date]
    instrument_weight = instrument_weight[['instrument', 'weight']]
    instrument_weight1 = instrument_weight.reset_index(drop = True)
    instrument_weight2 = instrument_weight1.set_index('instrument')
    ins = instrument_weight2.index.to_list()
    df6 = DataSource("basic_info_CN_FUND").read()
    df7 = DataSource("basic_info_CN_MUTFUND").read()
    name = []
    for value in ins:
        is_named = False
        for index1, row1 in df7.iterrows():
            if value == row1['instrument']:
                name.append(row1['sec_short_name'])
                is_named = True
                break
        if not is_named:
            for index2, row2 in df6.iterrows():
                if value == row2['instrument']:
                    name.append(row2['name'])
                    is_named = True
                    break
    instrument_weight2.index = name    
    data_1 = DataSource.write_df(group_all)
    data_2 = DataSource.write_df(instrument_weight2)
    return Outputs(data_1=data_1, data_2=data_2, data_3=None)

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

# 回测引擎：初始化函数，只执行一次
def m10_initialize_bigquant_run(context):
    # 加载预测数据
    context.ranker_prediction = context.options['data'].read_df()

    # 系统已经设置了默认的交易手续费和滑点，要修改手续费可使用如下函数
    context.set_commission(PerOrder(buy_cost=0.0003, sell_cost=0.0013, min_cost=5))
    # 预测数据，通过options传入进来，使用 read_df 函数，加载到内存 (DataFrame)
    # 设置买入的股票数量，这里买入预测股票列表排名靠前的5只
    #stock_count = 5
    # 每只的股票的权重，如下的权重分配会使得靠前的股票分配多一点的资金，[0.339160, 0.213986, 0.169580, ..]
    #context.stock_weights = T.norm([1 / math.log(i + 2) for i in range(0, stock_count)])
    # 设置每只股票占用的最大资金比例
    #context.max_cash_per_instrument = 0.2
    #context.hold_days = 5
    
    #周期为22个交易日
    context.rebalance_days = 22

    # 如果策略运行中，需要将数据进行保存，可以借用extension这个对象，类型为dict
    # 比如当前运行的k线的索引，比如个股持仓天数、买入均价
    if 'index' not in context.extension:
        context.extension['index'] = 0

# 回测引擎：每日数据处理函数，每天执行一次
def m10_handle_data_bigquant_run(context, data):
    # 不在换仓日就return,相当于后面的代码只会一个月运行一次，买入的股票会持有1个月
    if  context.extension['index'] % context.rebalance_days != 0:
        context.extension['index'] += 1
        return 
    
    # 按日期过滤得到今日的预测数据
    date = data.current_dt.strftime('%Y-%m-%d')
    ranker_prediction = context.ranker_prediction[
        context.ranker_prediction.date == date]
    fund_amount = len(ranker_prediction)
    instrument_open = {}
    instrument_weight = {}
    
    for index, row in ranker_prediction.iterrows():
        instrument_open[row['instrument']] = row['open']
        instrument_weight[row['instrument']] = row['weight']
        
    #print('date: ', date, 'fund_amount: ', str(fund_amount))
    
    # 1. 资金分配
    # 平均持仓时间是hold_days，每日都将买入股票，每日预期使用 1/hold_days 的资金
    # 实际操作中，会存在一定的买入误差，所以在前hold_days天，等量使用资金；之后，尽量使用剩余资金（这里设置最多用等量的1.5倍）
    #is_staging = context.trading_day_index < context.hold_days # 是否在建仓期间（前 hold_days 天）
    #cash_avg = context.portfolio.portfolio_value / context.hold_days
    portfolio_value = context.portfolio.portfolio_value
    #cash_for_sell = cash_avg - (context.portfolio.cash - cash_for_buy)
    positions = {e.symbol: p.amount
                 for e, p in context.perf_tracker.position_tracker.positions.items()}
    '''
    # 2. 生成卖出订单：hold_days天之后才开始卖出；对持仓的股票，按StockRanker预测的排序末位淘汰
    if not is_staging and cash_for_sell > 0:
        equities = {e.symbol: e for e, p in context.perf_tracker.position_tracker.positions.items()}
        instruments = list(reversed(list(ranker_prediction.instrument[ranker_prediction.instrument.apply(
                lambda x: x in equities and not context.has_unfinished_sell_order(equities[x]))])))
        # print('rank order for sell %s' % instruments)
        for instrument in instruments:
            context.order_target(context.symbol(instrument), 0)
            cash_for_sell -= positions[instrument]
            if cash_for_sell <= 0:
                break
    '''
    # 3. 生成买入订单：按StockRanker预测的排序，买入前面的stock_count只股票
    if fund_amount > 0:
        weight = 1 / fund_amount
        #print('date: ', date, 'index: ', str(context.extension['index']), ' portfolio_value: ', str(portfolio_value), ' weight: ', str(weight))
        buy_instruments = list(ranker_prediction.instrument)
        #cash = cash_for_buy * buy_cash_weights
        #max_cash_per_instrument = context.portfolio.portfolio_value * context.max_cash_per_instrument
        for instrument, amount in positions.items():
            if instrument not in buy_instruments:
                context.order(context.symbol(instrument), - amount)
                        
        for i, instrument in enumerate(buy_instruments):
            #if cash > max_cash_per_instrument - positions.get(instrument, 0):
            # 确保股票持仓量不会超过每次股票最大的占用资金量
            #    cash = max_cash_per_instrument - positions.get(instrument, 0)
            #hold_amount = positions.get(instrument, 0)
            #open_price = instrument_open[instrument]
            #trade_amount = int((portfolio_value * weight - hold_amount * open_price) / open_price)
            #print('instrument: ', instrument, ' open_price: ', str(open_price), ' hold_amount： ', 'trade_amount: ', str(trade_amount))
            #if trade_amount > 100 or trade_amount < 0:
            context.order_target_percent(context.symbol(instrument), weight)
    context.extension['index'] += 1

# 回测引擎：准备数据，只执行一次
def m10_prepare_bigquant_run(context):
    pass

# 回测引擎：每个单位时间开始前调用一次，即每日开盘前调用一次。
def m10_before_trading_start_bigquant_run(context, data):
    pass


m1 = M.instruments.v2(
    start_date='2019-10-11',
    end_date='2022-10-11',
    market='CN_FUND',
    instrument_list='#159919.ZOF',
    max_count=0
)

m2 = M.cached.v3(
    run=m2_run_bigquant_run,
    post_run=m2_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m20 = M.cached.v3(
    input_1=m1.data,
    input_2=m2.data_1,
    run=m20_run_bigquant_run,
    post_run=m20_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m3 = M.cached.v3(
    input_1=m20.data_1,
    run=m3_run_bigquant_run,
    post_run=m3_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m4 = M.select_columns.v3(
    input_ds=m3.data_1,
    columns='date,instrument,return_0,close',
    reverse_select=False
)

m5 = M.instruments.v2(
    start_date='2019-10-11',
    end_date='2022-10-11',
    market='CN_MUTFUND',
    instrument_list='#000395.OFCN',
    max_count=0
)

m6 = M.cached.v3(
    run=m6_run_bigquant_run,
    post_run=m6_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m19 = M.cached.v3(
    input_1=m5.data,
    input_2=m6.data_1,
    run=m19_run_bigquant_run,
    post_run=m19_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m28 = M.cached.v3(
    input_1=m19.data_1,
    run=m28_run_bigquant_run,
    post_run=m28_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m29 = M.select_columns.v3(
    input_ds=m28.data_1,
    columns='date,instrument,return_0,close',
    reverse_select=False
)

m30 = M.cached.v3(
    input_2=m4.data,
    input_3=m29.data,
    run=m30_run_bigquant_run,
    post_run=m30_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m31 = M.set_inf_to_nan.v1(
    input_1=m30.data_1
)

m33 = M.pivot_fbfill_stack.v3(
    input_1=m31.data_1,
    index_col='date',
    col_name='instrument',
    values_col='return_0'
)

m34 = M.pandas_pivot_table.v1(
    input_data=m33.data,
    index='date',
    columns='instrument',
    values='return_0',
    flat=False
)

m35 = M.dropnan.v2(
    input_data=m34.data_1
)

m36 = M.cached.v3(
    input_1=m35.data,
    run=m36_run_bigquant_run,
    post_run=m36_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m37 = M.cached.v3(
    input_1=m36.data_1,
    run=m37_run_bigquant_run,
    post_run=m37_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m8 = M.cached.v3(
    input_1=m37.data_1,
    input_2=m5.data,
    run=m8_run_bigquant_run,
    post_run=m8_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m7 = M.cached.v3(
    input_1=m8.data_1,
    run=m7_run_bigquant_run,
    post_run=m7_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m12 = M.select_columns.v3(
    input_ds=m7.data_1,
    columns='date,instrument,open,high,low,close,adjust_factor,volume',
    reverse_select=False
)

m9 = M.cached.v3(
    input_1=m8.data_2,
    run=m9_run_bigquant_run,
    post_run=m9_post_run_bigquant_run,
    input_ports='',
    params='',
    output_ports=''
)

m13 = M.select_columns.v3(
    input_ds=m9.data_1,
    columns='date,instrument,open,high,low,close,adjust_factor,volume',
    reverse_select=False
)

m11 = M.cached.v3(
    input_1=m12.data,
    input_2=m13.data,
    run=m11_run_bigquant_run,
    post_run=m11_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports='',
    m_cached=False
)

m10 = M.trade.v4(
    instruments=m8.data_1,
    options_data=m11.data_1,
    history_ds=m11.data_1,
    start_date='2019-10-11',
    end_date='2022-10-11',
    initialize=m10_initialize_bigquant_run,
    handle_data=m10_handle_data_bigquant_run,
    prepare=m10_prepare_bigquant_run,
    before_trading_start=m10_before_trading_start_bigquant_run,
    volume_limit=0.025,
    order_price_field_buy='open',
    order_price_field_sell='open',
    capital_base=100000,
    auto_cancel_non_tradable_orders=True,
    data_frequency='daily',
    price_type='后复权',
    product_type='股票',
    plot_charts=True,
    backtest_only=False,
    benchmark='000300.HIX'
)

m15 = M.plot_dataframe.v1(
    input_data=m11.data_2,
    title='无相关性基金权重图',
    chart_type='pie',
    x='',
    y='',
    options={
    'chart': {
        'height': 400
    }
},
    candlestick=False,
    pane_1='',
    pane_2='',
    pane_3='',
    pane_4=''
)

m14 = M.df_stastic1.v1(
    input_1=m37.data_2,
    type_num=1,
    columns=["PassengerId"]
)

[2022-11-03 17:53:02.177607] INFO: moduleinvoker: instruments.v2 开始运行..

[2022-11-03 17:53:02.411158] INFO: moduleinvoker: instruments.v2 运行完成[0.233546s].

[2022-11-03 17:53:02.426776] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:53:02.573404] INFO: moduleinvoker: cached.v3 运行完成[0.146634s].

[2022-11-03 17:53:02.587889] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:53:04.439864] INFO: moduleinvoker: cached.v3 运行完成[1.851935s].

[2022-11-03 17:53:04.466641] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:53:11.588660] INFO: moduleinvoker: cached.v3 运行完成[7.122049s].

[2022-11-03 17:53:15.113290] INFO: moduleinvoker: select_columns.v3 开始运行..

[2022-11-03 17:53:15.511281] INFO: moduleinvoker: select_columns.v3 运行完成[0.398012s].

[2022-11-03 17:53:15.520175] INFO: moduleinvoker: instruments.v2 开始运行..

[2022-11-03 17:53:15.580974] INFO: moduleinvoker: instruments.v2 运行完成[0.060793s].

[2022-11-03 17:53:15.597208] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:53:16.807940] INFO: moduleinvoker: cached.v3 运行完成[1.210732s].

[2022-11-03 17:53:16.888001] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:53:43.727226] INFO: moduleinvoker: cached.v3 运行完成[26.839216s].

[2022-11-03 17:53:43.762742] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:54:05.896185] INFO: moduleinvoker: cached.v3 运行完成[22.133455s].

[2022-11-03 17:54:05.916358] INFO: moduleinvoker: select_columns.v3 开始运行..

[2022-11-03 17:54:23.071272] INFO: moduleinvoker: select_columns.v3 运行完成[17.154918s].

[2022-11-03 17:54:23.100179] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:54:39.623837] INFO: moduleinvoker: cached.v3 运行完成[16.523661s].

[2022-11-03 17:54:39.760756] INFO: moduleinvoker: set_inf_to_nan.v1 开始运行..

[2022-11-03 17:54:55.178917] INFO: moduleinvoker: set_inf_to_nan.v1 运行完成[15.418163s].

[2022-11-03 17:54:55.303528] INFO: moduleinvoker: pivot_fbfill_stack.v3 开始运行..

[2022-11-03 17:55:16.493011] INFO: moduleinvoker: pivot_fbfill_stack.v3 运行完成[21.189472s].

[2022-11-03 17:55:16.563235] INFO: moduleinvoker: pandas_pivot_table.v1 开始运行..

[2022-11-03 17:55:40.257673] INFO: moduleinvoker: pandas_pivot_table.v1 运行完成[23.694464s].

[2022-11-03 17:55:40.277989] INFO: moduleinvoker: dropnan.v2 开始运行..

[2022-11-03 17:55:42.356293] INFO: dropnan: /data, 842/842

[2022-11-03 17:55:42.425239] INFO: dropnan: 行数: 842/842

[2022-11-03 17:55:42.434841] INFO: moduleinvoker: dropnan.v2 运行完成[2.156839s].

[2022-11-03 17:55:42.451498] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:55:43.428202] INFO: moduleinvoker: cached.v3 运行完成[0.976684s].

[2022-11-03 17:55:43.488318] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:56:27.783820] INFO: moduleinvoker: cached.v3 运行完成[44.295507s].

[2022-11-03 17:56:27.869168] INFO: moduleinvoker: cached.v3 开始运行..

[2022-11-03 17:56:28.146332] INFO: moduleinvoker: cached.v3 运行完成[0.277197s].

[2022-11-03 17:56:28.201433] INFO: moduleinvoker: cached.v3 开始运行..

列： ['date', 'instrument', 'return_0', 'close']
/data: 83564

列： ['date', 'instrument', 'return_0', 'close']
/data: 4533009