Data mining (#103)

* scen

* scen2

* app

* fix

* Simplify workflow

* We can share more code in new scenarios

* rename model to rd loop

* Optimize data path

* Update rdagent/app/data_mining/model.py

* Add TODO

* Support GPU

* gpu

---------

Co-authored-by: SH-Src <suhan.c@outlook.com>

rdagent/components/proposal/model_proposal.py

@@ -15,12 +15,14 @@ from rdagent.core.proposal import (
 )
 from rdagent.oai.llm_utils import APIBackend
 
-prompt_dict = Prompts(file_path=Path(__file__).parent / "prompts.yaml")
 
 ModelHypothesis = Hypothesis
 
+prompt_dict = Prompts(file_path=Path(__file__).parent / "prompts.yaml")
 
 class ModelHypothesisGen(HypothesisGen):
+    prompts: Prompts = prompt_dict
+
     # The following methods are scenario related so they should be implemented in the subclass
     @abstractmethod
     def prepare_context(self, trace: Trace) -> Tuple[dict, bool]:
@@ -35,7 +37,7 @@ class ModelHypothesisGen(HypothesisGen):
 
         system_prompt = (
             Environment(undefined=StrictUndefined)
-            .from_string(prompt_dict["hypothesis_gen"]["system_prompt"])
+            .from_string(ModelHypothesisGen.prompts["hypothesis_gen"]["system_prompt"])
             .render(
                 targets="model",
                 scenario=self.scen.get_scenario_all_desc(),
@@ -45,7 +47,7 @@ class ModelHypothesisGen(HypothesisGen):
         )
         user_prompt = (
             Environment(undefined=StrictUndefined)
-            .from_string(prompt_dict["hypothesis_gen"]["user_prompt"])
+            .from_string(ModelHypothesisGen.prompts["hypothesis_gen"]["user_prompt"])
             .render(
                 targets="model",
                 hypothesis_and_feedback=context_dict["hypothesis_and_feedback"],
@@ -61,6 +63,8 @@ class ModelHypothesisGen(HypothesisGen):
 
 
 class ModelHypothesis2Experiment(Hypothesis2Experiment[ModelExperiment]):
+    prompts: Prompts = prompt_dict
+
     def __init__(self) -> None:
         super().__init__()
 
@@ -76,7 +80,7 @@ class ModelHypothesis2Experiment(Hypothesis2Experiment[ModelExperiment]):
         context, json_flag = self.prepare_context(hypothesis, trace)
         system_prompt = (
             Environment(undefined=StrictUndefined)
-            .from_string(prompt_dict["hypothesis2experiment"]["system_prompt"])
+            .from_string(ModelHypothesis2Experiment.prompts["hypothesis2experiment"]["system_prompt"])
             .render(
                 targets="model",
                 scenario=trace.scen.get_scenario_all_desc(),
@@ -85,7 +89,7 @@ class ModelHypothesis2Experiment(Hypothesis2Experiment[ModelExperiment]):
         )
         user_prompt = (
             Environment(undefined=StrictUndefined)
-            .from_string(prompt_dict["hypothesis2experiment"]["user_prompt"])
+            .from_string(ModelHypothesis2Experiment.prompts["hypothesis2experiment"]["user_prompt"])
             .render(
                 targets="model",
                 target_hypothesis=context["target_hypothesis"],

rdagent/components/workflow/conf.py

@@ -0,0 +1,21 @@
+from pydantic_settings import BaseSettings
+
+class BasePropSetting(BaseSettings):
+    """
+    The common part of the config for RD Loop to propose and developement
+    You can add following config in the subclass to distinguish the environment variables.
+
+    .. code-block:: python
+
+        class Config:
+            env_prefix = "DM_MODEL_"  # Use MODEL_CODER_ as prefix for environment variables
+            protected_namespaces = ()  # Add 'model_' to the protected namespaces
+    """
+    scen: str = ""
+    hypothesis_gen: str = ""
+    hypothesis2experiment: str = ""
+    coder: str = ""
+    runner: str = ""
+    summarizer: str = ""
+
+    evolving_n: int = 10

rdagent/components/workflow/rd_loop.py

@@ -0,0 +1,64 @@
+"""
+Model workflow with session control
+It is from `rdagent/app/qlib_rd_loop/model.py` and try to replace `rdagent/app/qlib_rd_loop/RDAgent.py`
+"""
+
+from typing import Any
+from rdagent.components.workflow.conf import BasePropSetting
+from rdagent.core.developer import Developer
+from rdagent.core.proposal import (
+    Hypothesis2Experiment,
+    HypothesisExperiment2Feedback,
+    HypothesisGen,
+    Trace,
+)
+from rdagent.core.scenario import Scenario
+from rdagent.core.utils import import_class
+from rdagent.log import rdagent_logger as logger
+
+from rdagent.utils.workflow import LoopMeta, LoopBase
+
+class RDLoop(LoopBase, metaclass=LoopMeta):
+
+    def __init__(self, PROP_SETTING: BasePropSetting):
+        scen: Scenario = import_class(PROP_SETTING.scen)()
+
+        self.hypothesis_gen: HypothesisGen = import_class(PROP_SETTING.hypothesis_gen)(scen)
+
+        self.hypothesis2experiment: Hypothesis2Experiment = import_class(PROP_SETTING.hypothesis2experiment)()
+
+        self.coder: Developer = import_class(PROP_SETTING.coder)(scen)
+        self.runner: Developer = import_class(PROP_SETTING.runner)(scen)
+
+        self.summarizer: HypothesisExperiment2Feedback = import_class(PROP_SETTING.summarizer)(scen)
+        self.trace = Trace(scen=scen)
+        super().__init__()
+
+    def propose(self, prev_out: dict[str, Any]):
+        with logger.tag("r"):  # research
+            hypothesis = self.hypothesis_gen.gen(self.trace)
+            logger.log_object(hypothesis, tag="hypothesis generation")
+        return hypothesis
+
+    def exp_gen(self, prev_out: dict[str, Any]):
+        with logger.tag("r"):  # research
+            exp = self.hypothesis2experiment.convert(prev_out["propose"], self.trace)
+            logger.log_object(exp.sub_tasks, tag="experiment generation")
+        return exp
+
+    def coding(self, prev_out: dict[str, Any]):
+        with logger.tag("d"):  # develop
+            exp = self.coder.develop(prev_out["exp_gen"])
+            logger.log_object(exp.sub_workspace_list, tag="coder result")
+        return exp
+
+    def running(self, prev_out: dict[str, Any]):
+        with logger.tag("ef"):  # evaluate and feedback
+            exp = self.runner.develop(prev_out["coding"])
+            logger.log_object(exp, tag="runner result")
+        return exp
+
+    def feedback(self, prev_out: dict[str, Any]):
+        feedback = self.summarizer.generate_feedback(prev_out["running"], prev_out["propose"], self.trace)
+        logger.log_object(feedback, tag="feedback")
+        self.trace.hist.append((prev_out["propose"],prev_out["running"] , feedback))