In [3]:

# 本代码由可视化策略环境自动生成 2023年8月29日 14:24
# 本代码单元只能在可视化模式下编辑。您也可以拷贝代码，粘贴到新建的代码单元或者策略，然后修改。
 
# 显式导入 BigQuant 相关 SDK 模块
from bigdatasource.api import DataSource
from bigdata.api.datareader import D
from biglearning.api import M
from biglearning.api import tools as T
from biglearning.module2.common.data import Outputs
 
import pandas as pd
import numpy as np
import math
import warnings
import datetime
 
from zipline.finance.commission import PerOrder
from zipline.api import get_open_orders
from zipline.api import symbol
 
from bigtrader.sdk import *
from bigtrader.utils.my_collections import NumPyDeque
from bigtrader.constant import OrderType
from bigtrader.constant import Direction

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m20_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    df = input_1.read()
    df[df['list_days_0']>365]
    df[df['pe_ttm_0']>0]
    df[df['rank_turn_0']<0.5]
    
    # 缺失值处理
    df.replace([np.inf, -np.inf], np.nan, inplace=True)
    df.dropna(inplace=True)
    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 m15_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    data = input_1.read()
    df = input_2.read()
    columns = list(input_3.read())
    data = pd.merge(data, df, on=['date', 'instrument'], how='inner')
    data = data[['date', 'instrument', 'market_cap_0'] + columns]
    data_1 = DataSource.write_df(data)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# Python 代码入口函数，input_1/2/3 对应三个输入端，data_1/2/3 对应三个输出端
def m16_run_bigquant_run(input_1, input_2, input_3):
    # 示例代码如下。在这里编写您的代码
    import torch
    import torch.nn.init as init
    import numpy as np
    import torch.nn as nn
    
    try:
        model_params = input_1.read()
    except:
        print('加载模型')
        model_params = torch.load("/home/aiuser/work/userlib/model.pth")
    data = input_2.read()
    df = data[['date', 'instrument', 'market_cap_0']]
    columns = list(input_3.read())
    x = np.array(data[columns])
    x = torch.Tensor(x)
    
    # 模型建立
    class net(nn.Module):
        def __init__(self):
            super(net, self).__init__()
            self.fc1 = nn.Linear(x.shape[1], 256)
            self.sig = nn.Sigmoid()
            self.relu = nn.ReLU()
            self.fc2 = nn.Linear(256, 128)
            self.fc3 = nn.Linear(128, 2)
            self.softmax = nn.Softmax(dim=0)
       
            # 将参数初始化为较小的值
            init.xavier_uniform_(self.fc1.weight)
            init.xavier_uniform_(self.fc2.weight)
            init.xavier_uniform_(self.fc3.weight)
        
        def forward(self, data):
            out = self.fc1(data)
            out = self.sig(out)
            out = self.fc2(out)
            out = self.relu(out)
            out = self.fc3(out)
            out = self.softmax(out)
            return out
        
    model = net()
    model.load_state_dict(model_params)
    ypre = model(x).detach().numpy()
    df['pre'] = np.argmax(ypre, axis=1)
    data_1 = DataSource.write_df(df)
    return Outputs(data_1=data_1, data_2=None, data_3=None)

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

# 交易引擎：初始化函数，只执行一次
def m17_initialize_bigquant_run(context):
    # 加载预测数据
    context.df = context.options['data'].read_df()
    
    # 计时器
    context.index = -2
    
    # 调仓周期
    context.T = 3

# 交易引擎：每个单位时间开盘前调用一次。
def m17_before_trading_start_bigquant_run(context, data):
    # 盘前处理，订阅行情等
    pass

# 交易引擎：tick数据处理函数，每个tick执行一次
def m17_handle_tick_bigquant_run(context, tick):
    pass

# 交易引擎：bar数据处理函数，每个时间单位执行一次
def m17_handle_data_bigquant_run(context, data):
    context.index += 1
    if context.index % context.T == 0:
        return
    
    dt = data.current_dt.strftime('%Y-%m-%d')

    df = context.df[context.df['date']==dt]
    df.sort_values('market_cap_0', ascending=True)
    
    in_df = df[df['pre']>0]          # 获取预测值大于0的股票
    instrument = list(in_df.instrument)
    
    # 获取持仓列表
    account = context.get_account_positions()
    holding_account = list(account.keys())
    holding_num = len(holding_account)
    
    # 获取可用资金和总资金
    cash = context.get_trading_account()
    total_cash = cash.portfolio_value
    avail_cash = cash.available
    
    # 卖出
    sell_list = []
    out = 0
    for ins in holding_account:
        if ins not in instrument:
            context.order_target(ins, 0)
            sell_list.append(ins)
            out += 1
    
    # 买入
    buy_list = []
    for ins in instrument:
        if holding_num - out < 20 and avail_cash > total_cash/20 and ins not in holding_account: 
            context.order_target_percent(ins, 1/20)
            buy_list.append(ins)
            avail_cash -= total_cash/20
#     print(dt, ' 买入', buy_list)
#     print(dt, ' 卖出', sell_list)
    

# 交易引擎：成交回报处理函数，每个成交发生时执行一次
def m17_handle_trade_bigquant_run(context, trade):
    pass

# 交易引擎：委托回报处理函数，每个委托变化时执行一次
def m17_handle_order_bigquant_run(context, order):
    pass

# 交易引擎：盘后处理函数，每日盘后执行一次
def m17_after_trading_bigquant_run(context, data):
    pass


m3 = M.input_features.v1(
    features="""close_0
open_0
low_0
high_0

close_1
open_1
low_1
high_1

close_2
open_2
low_2
high_2

close_3
open_3
low_3
high_3

close_4
open_4
low_4
high_4

close_5
open_5
low_5
high_5"""
)

m10 = M.input_features.v1(
    features="""market_cap_0
pe_ttm_0
list_days_0
rank_turn_0"""
)

m13 = M.instruments.v2(
    start_date=T.live_run_param('trading_date', '2023-01-01'),
    end_date=T.live_run_param('trading_date', '2023-08-24'),
    market='CN_STOCK_A',
    instrument_list='',
    max_count=0
)

m14 = M.general_feature_extractor.v7(
    instruments=m13.data,
    features=m3.data,
    start_date='',
    end_date='',
    before_start_days=90
)

m18 = M.general_feature_extractor.v7(
    instruments=m13.data,
    features=m10.data,
    start_date='',
    end_date='',
    before_start_days=90
)

m19 = M.chinaa_stock_filter.v1(
    input_data=m18.data,
    index_constituent_cond=['中证500', '中证800', '中证100', '中证1000'],
    board_cond=['上证主板', '深证主板', '创业板'],
    industry_cond=['银行', '非银金融'],
    st_cond=['正常'],
    delist_cond=['非退市'],
    output_left_data=False
)

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

m15 = M.cached.v3(
    input_1=m20.data_1,
    input_2=m14.data,
    input_3=m3.data,
    run=m15_run_bigquant_run,
    post_run=m15_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports=''
)

m16 = M.cached.v3(
    input_2=m15.data_1,
    input_3=m3.data,
    run=m16_run_bigquant_run,
    post_run=m16_post_run_bigquant_run,
    input_ports='',
    params='{}',
    output_ports='',
    m_cached=False
)

m17 = M.hftrade.v2(
    instruments=m13.data,
    options_data=m16.data_1,
    start_date='',
    end_date='',
    initialize=m17_initialize_bigquant_run,
    before_trading_start=m17_before_trading_start_bigquant_run,
    handle_tick=m17_handle_tick_bigquant_run,
    handle_data=m17_handle_data_bigquant_run,
    handle_trade=m17_handle_trade_bigquant_run,
    handle_order=m17_handle_order_bigquant_run,
    after_trading=m17_after_trading_bigquant_run,
    capital_base=1000000,
    frequency='daily',
    price_type='真实价格',
    product_type='股票',
    before_start_days='0',
    volume_limit=1,
    order_price_field_buy='open',
    order_price_field_sell='close',
    benchmark='000300.HIX',
    plot_charts=True,
    disable_cache=False,
    replay_bdb=False,
    show_debug_info=False,
    backtest_only=False
)

加载模型

/tmp/ipykernel_21268/697736252.py:105: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame.
Try using .loc[row_indexer,col_indexer] = value instead

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  df['pre'] = np.argmax(ypre, axis=1)

[2023-08-29 14:25:23.655660] INFO hfbacktest: biglearning V1.5.0d

INFO:hfbacktest:biglearning V1.5.0d

[2023-08-29 14:25:23.662311] INFO hfbacktest: bigtrader v1.10.4 2023-08-25

INFO:hfbacktest:bigtrader v1.10.4 2023-08-25
/usr/local/python3/lib/python3.8/site-packages/empyrical/stats.py:799: RuntimeWarning: divide by zero encountered in true_divide
  np.divide(average_annual_return, annualized_downside_risk, out=out)
/usr/local/python3/lib/python3.8/site-packages/pandas/core/generic.py:2605: PerformanceWarning: 
your performance may suffer as PyTables will pickle object types that it cannot
map directly to c-types [inferred_type->mixed,key->block3_values] [items->Index(['orders', 'transactions', 'positions', 'POS_FAC', 'TRA_FAC', 'LOG'], dtype='object')]

  pytables.to_hdf(

[2023-08-29 14:26:07.591708] INFO hfbacktest: backtest done, raw_perf_ds:DataSource(2de7ca2404b34dba85eac0a70cee8537T)

INFO:hfbacktest:backtest done, raw_perf_ds:DataSource(2de7ca2404b34dba85eac0a70cee8537T)
/usr/local/python3/lib/python3.8/site-packages/pandas/core/indexing.py:1637: SettingWithCopyWarning: 
A value is trying to be set on a copy of a slice from a DataFrame

See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy
  self._setitem_single_block(indexer, value, name)
[2023-08-29 14:26:12.218701] INFO: bigcharts.impl.render:render.py:408:render_chart Data is None, skip loading it to chart.

收益率11.2%
年化收益率17.78%
基准收益率-4.23%
阿尔法0.29
贝塔1.08
夏普比率0.85
胜率1.0
盈亏比0.0
收益波动率18.56%
信息比率0.14
最大回撤9.43%

日期	时间	股票代码	股票名称	买/卖	数量	成交价	总成本	交易佣金
Loading... (need help?)

日期	标的代码	标的名称	持仓均价	收盘价	数量	持仓价值	收益
Loading... (need help?)

时间	级别	内容
Loading... (need help?)