1
2
3
4
5
6

class RAGStrategy:
    def query(self, evo, evolving_trace) -> QueriedKnowledge:
        # 基于当前状态和历史经验检索相关知识
    
    def generate_knowledge(self, evolving_trace) -> Knowledge:
        # 从实验历史中生成新知识

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

class QlibFBWorkspace(FBWorkspace):
    def execute(self, qlib_config_name: str = "conf.yaml", run_env: dict = {}):
        # 选择执行环境 (Docker/Conda)
        if MODEL_COSTEER_SETTINGS.env_type == "docker":
            qtde = QTDockerEnv()
        elif MODEL_COSTEER_SETTINGS.env_type == "conda":
            qtde = QlibCondaEnv(conf=QlibCondaConf())
        
        # 执行Qlib回测
        execute_qlib_log = qtde.check_output(
            local_path=str(self.workspace_path),
            entry=f"qrun {qlib_config_name}",
            env=run_env,
        )
        
        # 读取实验结果
        execute_log = qtde.check_output(
            local_path=str(self.workspace_path),
            entry="python read_exp_res.py",
            env=run_env,
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

class QlibFactorRunner(CachedRunner[QlibFactorExperiment]):
    def develop(self, exp: QlibFactorExperiment) -> QlibFactorExperiment:
        # 1. 处理历史因子数据
        if exp.based_experiments:
            SOTA_factor = process_factor_data(sota_factor_experiments_list)
            new_factors = process_factor_data(exp)
            
            # 2. 因子去重和合并
            new_factors = self.deduplicate_new_factors(SOTA_factor, new_factors)
            combined_factors = pd.concat([SOTA_factor, new_factors], axis=1)
            
            # 3. 保存合并后的因子数据
            combined_factors.to_parquet("combined_factors_df.parquet")
        
        # 4. 执行Qlib实验
        result, stdout = exp.experiment_workspace.execute(
            qlib_config_name="conf_combined_factors.yaml"
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

class QlibModelRunner(CachedRunner[QlibModelExperiment]):
    def develop(self, exp: QlibModelExperiment) -> QlibModelExperiment:
        # 1. 处理基础因子实验
        if exp.based_experiments and exp.based_experiments[-1].result is None:
            exp.based_experiments[-1] = self.develop(exp.based_experiments[-1])
        
        # 2. 合并SOTA因子
        if exp.based_experiments:
            SOTA_factor = process_factor_data(sota_factor_experiments_list)
            combined_factors = SOTA_factor
            combined_factors.to_parquet("combined_factors_df.parquet")
        
        # 3. 注入模型代码
        exp.experiment_workspace.inject_files(
            **{"model.py": exp.sub_workspace_list[0].file_dict["model.py"]}
        )
        
        # 4. 执行模型训练
        result, stdout = exp.experiment_workspace.execute(
            qlib_config_name="conf_combined_factors_sota_model.yaml",
            run_env=env_to_use
        )

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class QlibDockerConf(DockerConf):
    build_from_dockerfile: bool = True
    dockerfile_folder_path: Path = Path("scenarios/qlib/docker")
    image: str = "local_qlib:latest"
    mount_path: str = "/workspace/qlib_workspace/"
    default_entry: str = "qrun conf.yaml"
    extra_volumes: dict = {
        "~/.qlib/": {"bind": "/root/.qlib/", "mode": "rw"}
    }
    shm_size: str = "16g"
    enable_gpu: bool = True

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

class QlibCondaConf(CondaConf):
    conda_env_name: str = "rdagent4qlib"
    default_entry: str = "qrun conf.yaml"
    enable_cache: bool = False

class QlibCondaEnv(LocalEnv[QlibCondaConf]):
    def prepare(self):
        # 自动创建conda环境并安装Qlib
        subprocess.check_call(f"conda create -y -n {self.conf.conda_env_name} python=3.10")
        subprocess.check_call(f"conda run -n {self.conf.conda_env_name} pip install git+https://github.com/microsoft/qlib.git")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

qlib_init:
    provider_uri: "~/.qlib/qlib_data/cn_data"
    region: cn

data_handler_config:
    start_time: 2008-01-01
    end_time: 2020-08-01
    instruments: csi300
    # 基础Alpha158因子

task:
    model:
        class: LGBModel
        module_path: qlib.contrib.model.gbdt
    dataset:
        class: DatasetH
        module_path: qlib.data.dataset

1
2
3
4
5
6
7
8
9

data_handler_config:
    data_loader:
        class: NestedDataLoader
        kwargs:
            dataloader_l:
                - class: qlib.contrib.data.loader.Alpha158DL
                - class: qlib.data.dataset.loader.StaticDataLoader
                  kwargs:
                    config: "combined_factors_df.parquet"  # RD-Agent生成的因子

1
2

# 结合SOTA因子和SOTA模型的配置
# 支持PyTorch模型和传统ML模型

1
2
3
4
5
6
7
8

def deduplicate_new_factors(self, SOTA_feature, new_feature):
    # 计算信息系数(IC)相关性
    IC_max = concat_feature.groupby("datetime").parallel_apply(
        lambda x: self.calculate_information_coefficient(x, SOTA_feature.shape[1], new_feature.shape[1])
    ).mean()
    
    # 移除高相关性因子 (IC > 0.99)
    return new_feature.iloc[:, IC_max[IC_max < 0.99].index]

1
2
3
4
5

# read_exp_res.py - 自动解析Qlib实验结果
experiments = R.list_experiments()
latest_recorder = R.get_recorder(recorder_id=recorder_id, experiment_name=experiment)
metrics = pd.Series(latest_recorder.list_metrics())
ret_data_frame = latest_recorder.load_object("portfolio_analysis/report_normal_1day.pkl")

1

rdagent fin_factor  # 启动因子自动进化

1

rdagent fin_model   # 启动模型自动进化

1

rdagent fin_quant   # 启动因子+模型联合优化