复制链接

克隆策略

In [36]:

m6.sorted_data.read()

Out[36]:

	date	instrument	return_5
0	2021-12-22	002319.SZA	0.763372
1	2021-12-22	831445.BJA	0.773495
2	2021-12-22	600367.SHA	0.789092
3	2021-12-22	002607.SZA	0.800199
4	2021-12-22	603335.SHA	0.817362
...	...	...	...
58370	2022-01-10	600941.SHA	NaN
58371	2022-01-10	603176.SHA	NaN
58372	2022-01-10	688176.SHA	NaN
58373	2022-01-10	688262.SHA	NaN
58374	2022-01-10	871245.BJA	NaN

58375 rows × 3 columns

In [38]:

m7.data_1

Out[38]:

	date	instrument	return_5	num	buy_condition
0	2021-12-22	002319.SZA	0.763372	0	1.0
1	2021-12-22	831445.BJA	0.773495	1	1.0
2	2021-12-22	600367.SHA	0.789092	2	1.0
3	2021-12-22	002607.SZA	0.800199	3	1.0
4	2021-12-22	603335.SHA	0.817362	4	1.0
...	...	...	...	...	...
58370	2022-01-10	600941.SHA	NaN	4382	0.0
58371	2022-01-10	603176.SHA	NaN	4383	0.0
58372	2022-01-10	688176.SHA	NaN	4384	0.0
58373	2022-01-10	688262.SHA	NaN	4385	0.0
58374	2022-01-10	871245.BJA	NaN	4386	0.0

58375 rows × 5 columns

In [39]:

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


# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
###定义回调函数
def set_value(x):      
    x['num']=x.index%len(x)
    x.loc[x['num']<5,'buy_condition']=1
    x.loc[x['num']>=5,'buy_condition']=0
    return x  


def m7_run_bigquant_run(input_1): 
    df = input_1.read()
    ##排在前5位的开仓条件为1，其他为0 

 
    df=df.groupby('date').apply(set_value)
    data_1=df
    return Outputs(data_1=data_1)
    

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

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

    # 系统已经设置了默认的交易手续费和滑点，要修改手续费可使用如下函数
    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

# 回测引擎：每日数据处理函数，每天执行一次
def m5_handle_data_bigquant_run(context, data):   
    # 获取今日的日期
    today =context.get_datetime() 
    print("===============%s执行1次主函数==================="%today)
    
    today = data.current_dt.strftime('%Y-%m-%d') 
     # 通过positions对象，使用列表生成式的方法获取目前持仓的股票列表
    stock_hold_now = {e.symbol: p.amount * p.last_sale_price
                 for e, p in context.perf_tracker.position_tracker.positions.items()}
    
   

    context.daily_stock_sell=[k for k in stock_hold_now if k not in context.daily_stock_buy]
   
   
    print("-----要买的股票列表----：")
    print(context.daily_stock_buy)#打印要买的股票
    print("-----要卖的股票列表----：")
    print(context.daily_stock_sell)#打印要卖的股票
    
    print('获取当前时间： ', context.get_datetime())
    # 通过positions对象，使用列表生成式的方法获取目前持仓的股票列表
    stock_hold_now = {e.symbol: p.amount * p.last_sale_price
                 for e, p in context.perf_tracker.position_tracker.positions.items()}
    print('目前持仓的股票列表:',today,stock_hold_now)
    
    
    # 记录用于买入股票的可用现金,因为是早盘卖股票，需要记录卖出的股票市值并在买入下单前更新可用现金；
    # 如果是早盘买尾盘卖，则卖出时不需更新可用现金，因为尾盘卖出股票所得现金无法使用
    cash_for_buy = context.portfolio.cash    
    
    try:
        buy_stock = context.daily_stock_buy[today]  # 当日符合买入条件的股票
        print('进行买入处理:',today,buy_stock)
        print('买入时间:',context.get_datetime())
    except:
        buy_stock=[]  # 如果没有符合条件的股票，就设置为空
    
    try:
        sell_stock = context.daily_stock_sell[today]  # 当日符合卖出条件的股票
        print('进行卖出处理:',today,sell_stock)      
        print('卖出时间:',context.get_datetime())
    except:
        sell_stock=[] # 如果没有符合条件的股票，就设置为空
    
    # 需要卖出的股票:已有持仓中符合卖出条件的股票
    stock_to_sell = [ i for i in stock_hold_now if i in sell_stock ]
    # 需要买入的股票:没有持仓且符合买入条件的股票
    stock_to_buy = [ i for i in buy_stock if i not in stock_hold_now ]  
    # 需要调仓的股票：已有持仓且不符合卖出条件的股票
    stock_to_adjust=[ i for i in stock_hold_now if i not in sell_stock ]
    
    # 如果有卖出信号
    print('stock_to_sell:%s'%len(stock_to_sell))
    if len(stock_to_sell)>0:
        for instrument in stock_to_sell:
            sid = context.symbol(instrument) # 将标的转化为equity格式
            cur_position = context.portfolio.positions[sid].amount # 持仓
            if cur_position > 0 and data.can_trade(sid):
                print("--------调用卖出函数-------")
                context.order_target_percent(sid, 0) # 全部卖出 
                # 因为设置的是早盘卖出早盘买入，需要根据卖出的股票更新可用现金；如果设置尾盘卖出早盘买入，则不需更新可用现金(可以删除下面的语句)
                #cash_for_buy += stock_hold_now[instrument]
        
        
    # 如果有买入信号/有持仓
    if len(stock_to_buy)+len(stock_to_adjust)>0:
        weight = 1/(len(stock_to_buy)+len(stock_to_adjust)) # 每只股票的比重为等资金比例持有
        for instrument in stock_to_buy+stock_to_adjust:
            sid = context.symbol(instrument) # 将标的转化为equity格式
            if  data.can_trade(sid):
                print("sid:%s"%sid)
                print("cash_for_buy:%s"%cash_for_buy)
                print("--------调用买入函数-------")
                context.order_target_value(sid, weight*cash_for_buy) # 买入，调仓到目标份额，也可能是卖出部分哦
# 回测引擎：准备数据，只执行一次
def m5_prepare_bigquant_run(context):    
    print("执行数据准备函数")
    # 加载预测数据
    te= context.options['data']    
#     df = context.options['data'].read_df()
    df = context.options['data']

    # 函数：求满足开仓条件的股票列表
    def open_pos_con(df):
        return list(df[df['buy_condition']>0].instrument)

#     # 函数：求满足平仓条件的股票列表
#     def close_pos_con(df):
#         return list(df[df['sell_condition']>0].instrument)

    # 每日买入股票的数据框
    context.daily_stock_buy= df.groupby('date').apply(open_pos_con)
#     # 每日卖出股票的数据框

#     context.daily_stock_sell= df.groupby('date').apply(close_pos_con)

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


m1 = M.instruments.v2(
    start_date='2022-1-1',
    end_date='2022-1-10',
    market='CN_STOCK_A',
    instrument_list="""# 002820.SZA
# 600420.SHA
# 002421.SZA
# 601001.SHA
# 601011.SHA
# 601015.SHA
# 600490.SHA
# 600063.SHA
# 603011.SHA""",
    max_count=0
)

m2 = M.input_features.v1(
    features="""
#号开始的表示注释，注释需单独一行
# 多个特征，每行一个，可以包含基础特征和衍生特征，特征须为本平台特征
return_5
# return_10
# return_20
# avg_amount_0/avg_amount_5
# avg_amount_5/avg_amount_20
# rank_avg_amount_0/rank_avg_amount_5
# rank_avg_amount_5/rank_avg_amount_10
# rank_return_0
# rank_return_5
# rank_return_10
# rank_return_0/rank_return_5
# rank_return_5/rank_return_10
# pe_ttm_0

"""
)

m4 = M.general_feature_extractor.v7(
    instruments=m1.data,
    features=m2.data,
    start_date='',
    end_date='',
    before_start_days=10
)

m3 = M.chinaa_stock_filter.v1(
    input_data=m4.data,
    index_constituent_cond=['全部'],
    board_cond=['全部'],
    industry_cond=['全部'],
    st_cond=['正常'],
    delist_cond=['非退市'],
    output_left_data=True
)

m6 = M.sort.v5(
    input_ds=m3.data,
    sort_by='return_5',
    group_by='date',
    keep_columns='--',
    ascending=True
)

m7 = M.cached.v3(
    input_1=m6.sorted_data,
    run=m7_run_bigquant_run,
    post_run=m7_post_run_bigquant_run,
    input_ports='input_1',
    params='{}',
    output_ports='data_1'
)

m5 = M.trade.v4(
    instruments=m1.data,
    options_data=m7.data_1,
    start_date='',
    end_date='',
    initialize=m5_initialize_bigquant_run,
    handle_data=m5_handle_data_bigquant_run,
    prepare=m5_prepare_bigquant_run,
    before_trading_start=m5_before_trading_start_bigquant_run,
    volume_limit=0.025,
    order_price_field_buy='open',
    order_price_field_sell='close',
    capital_base=1000000,
    auto_cancel_non_tradable_orders=True,
    data_frequency='daily',
    price_type='真实价格',
    product_type='股票',
    plot_charts=True,
    backtest_only=False,
    benchmark='000300.HIX'
)

[2023-01-08 15:45:40.482459] INFO: moduleinvoker: instruments.v2 开始运行..

[2023-01-08 15:45:40.492558] INFO: moduleinvoker: 命中缓存

[2023-01-08 15:45:40.494318] INFO: moduleinvoker: instruments.v2 运行完成[0.01189s].

[2023-01-08 15:45:40.499263] INFO: moduleinvoker: input_features.v1 开始运行..

[2023-01-08 15:45:40.508838] INFO: moduleinvoker: 命中缓存

[2023-01-08 15:45:40.510641] INFO: moduleinvoker: input_features.v1 运行完成[0.01139s].

[2023-01-08 15:45:40.527049] INFO: moduleinvoker: general_feature_extractor.v7 开始运行..

[2023-01-08 15:45:40.537207] INFO: moduleinvoker: 命中缓存

[2023-01-08 15:45:40.538898] INFO: moduleinvoker: general_feature_extractor.v7 运行完成[0.011866s].

[2023-01-08 15:45:40.547849] INFO: moduleinvoker: chinaa_stock_filter.v1 开始运行..

[2023-01-08 15:45:40.562553] INFO: moduleinvoker: 命中缓存

[2023-01-08 15:45:40.564493] INFO: moduleinvoker: chinaa_stock_filter.v1 运行完成[0.016641s].

[2023-01-08 15:45:40.570184] INFO: moduleinvoker: sort.v5 开始运行..

[2023-01-08 15:45:40.575276] INFO: moduleinvoker: 命中缓存

[2023-01-08 15:45:40.576920] INFO: moduleinvoker: sort.v5 运行完成[0.006737s].

[2023-01-08 15:45:40.590550] INFO: moduleinvoker: cached.v3 开始运行..

[2023-01-08 15:45:40.942104] WARNING: modulecache: 返回的Outputs实例(size=5813378) 过大，将不会被缓存。

[2023-01-08 15:45:40.944447] INFO: moduleinvoker: cached.v3 运行完成[0.353923s].

[2023-01-08 15:45:40.988871] ERROR: moduleinvoker: module name: trade, module version: v4, trackeback: IndexError: list index out of range

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-39-e518e9149120> in <module>
    218 )
    219 
--> 220 m5 = M.trade.v4(
    221     instruments=m1.data,
    222     options_data=m7.data_1,

IndexError: list index out of range