Merge branch 'nested_decision_exe' of https://github.com/microsoft/qlib into rl-dummy

examples/nested_decision_execution/workflow.py

@@ -14,14 +14,13 @@ from qlib.tests.data import GetData
 from qlib.backtest import collect_data
 
 
-class NestedDecisonExecutionWorkflow:
+class NestedDecisionExecutionWorkflow:
 
     market = "csi300"
     benchmark = "SH000300"
-
     data_handler_config = {
         "start_time": "2008-01-01",
-        "end_time": "2021-01-20",
+        "end_time": "2020-12-31",
         "fit_start_time": "2008-01-01",
         "fit_end_time": "2014-12-31",
         "instruments": market,
@@ -53,9 +52,9 @@ class NestedDecisonExecutionWorkflow:
                     "kwargs": data_handler_config,
                 },
                 "segments": {
-                    "train": ("2008-01-01", "2014-12-31"),
+                    "train": ("2007-01-01", "2014-12-31"),
                     "valid": ("2015-01-01", "2016-12-31"),
-                    "test": ("2017-01-01", "2021-01-20"),
+                    "test": ("2020-01-01", "2020-12-31"),
                 },
             },
         },
@@ -66,35 +65,55 @@ class NestedDecisonExecutionWorkflow:
             "class": "NestedExecutor",
             "module_path": "qlib.backtest.executor",
             "kwargs": {
-                "time_per_step": "week",
+                "time_per_step": "day",
                 "inner_executor": {
-                    "class": "SimulatorExecutor",
+                    "class": "NestedExecutor",
                     "module_path": "qlib.backtest.executor",
                     "kwargs": {
-                        "time_per_step": "day",
-                        "verbose": True,
+                        "time_per_step": "30min",
+                        "inner_executor": {
+                            "class": "SimulatorExecutor",
+                            "module_path": "qlib.backtest.executor",
+                            "kwargs": {
+                                "time_per_step": "5min",
+                                "generate_report": True,
+                                "verbose": True,
+                                "indicator_config": {
+                                    "show_indicator": True,
+                                },
+                            },
+                        },
+                        "inner_strategy": {
+                            "class": "TWAPStrategy",
+                            "module_path": "qlib.contrib.strategy.rule_strategy",
+                        },
                         "generate_report": True,
+                        "indicator_config": {
+                            "show_indicator": True,
+                        },
                     },
                 },
                 "inner_strategy": {
                     "class": "SBBStrategyEMA",
                     "module_path": "qlib.contrib.strategy.rule_strategy",
                     "kwargs": {
-                        "freq": "day",
                         "instruments": market,
+                        "freq": "1min",
                     },
                 },
-                "generate_report": True,
                 "track_data": True,
+                "generate_report": True,
+                "indicator_config": {
+                    "show_indicator": True,
+                },
             },
         },
         "backtest": {
-            "start_time": "2017-01-01",
-            "end_time": "2020-08-01",
+            "start_time": "2020-01-01",
+            "end_time": "2020-12-31",
             "account": 100000000,
-            "benchmark": benchmark,
             "exchange_kwargs": {
-                "freq": "day",
+                "freq": "1min",
                 "limit_threshold": 0.095,
                 "deal_price": "close",
                 "open_cost": 0.0005,
@@ -106,11 +125,40 @@ class NestedDecisonExecutionWorkflow:
 
     def _init_qlib(self):
         """initialize qlib"""
-        provider_uri = "~/.qlib/qlib_data/cn_data"  # target_dir
-        if not exists_qlib_data(provider_uri):
-            print(f"Qlib data is not found in {provider_uri}")
-            GetData().qlib_data(target_dir=provider_uri, region=REG_CN)
-        qlib.init(provider_uri=provider_uri, region=REG_CN)
+        # provider_uri_day = "/data/stock_data/huaxia/qlib"
+        # provider_uri_1min = "/data2/stock_data/huaxia_1min_qlib"
+        provider_uri_day = "~/.qlib/qlib_data/cn_data"  # target_dir
+        GetData().qlib_data(target_dir=provider_uri_day, region=REG_CN, version="v2", exists_skip=True)
+        provider_uri_1min = HIGH_FREQ_CONFIG.get("provider_uri")
+        GetData().qlib_data(
+            target_dir=provider_uri_1min, interval="1min", region=REG_CN, version="v2", exists_skip=True
+        )
+        provider_uri_map = {"1min": provider_uri_1min, "day": provider_uri_day}
+        client_config = {
+            "calendar_provider": {
+                "class": "LocalCalendarProvider",
+                "module_path": "qlib.data.data",
+                "kwargs": {
+                    "backend": {
+                        "class": "FileCalendarStorage",
+                        "module_path": "qlib.data.storage.file_storage",
+                        "kwargs": {"provider_uri_map": provider_uri_map},
+                    }
+                },
+            },
+            "feature_provider": {
+                "class": "LocalFeatureProvider",
+                "module_path": "qlib.data.data",
+                "kwargs": {
+                    "backend": {
+                        "class": "FileFeatureStorage",
+                        "module_path": "qlib.data.storage.file_storage",
+                        "kwargs": {"provider_uri_map": provider_uri_map},
+                    }
+                },
+            },
+        }
+        qlib.init(provider_uri=provider_uri_day, **client_config, redis_port=-1)
 
     def _train_model(self, model, dataset):
         with R.start(experiment_name="train"):
@@ -145,12 +193,25 @@ class NestedDecisonExecutionWorkflow:
             },
         }
         self.port_analysis_config["strategy"] = strategy_config
+        self.port_analysis_config["backtest"]["benchmark"] = D.list_instruments(
+            instruments=D.instruments(market=self.market), as_list=True
+        )
         with R.start(experiment_name="backtest"):
 
             recorder = R.get_recorder()
-            par = PortAnaRecord(recorder, self.port_analysis_config, "day")
+            par = PortAnaRecord(
+                recorder,
+                self.port_analysis_config,
+                risk_analysis_freq=["day", "30min", "5min"],
+                indicator_analysis_freq=["day", "30min", "5min"],
+                indicator_analysis_method="value_weighted",
+            )
             par.generate()
 
+        # report_normal_df = recorder.load_object("portfolio_analysis/report_normal_1day.pkl")
+        # from qlib.contrib.report import analysis_position
+        # analysis_position.report_graph(report_normal_df)
+
     def collect_data(self):
         self._init_qlib()
         model = init_instance_by_config(self.task["model"])
@@ -158,6 +219,7 @@ class NestedDecisonExecutionWorkflow:
         self._train_model(model, dataset)
         executor_config = self.port_analysis_config["executor"]
         backtest_config = self.port_analysis_config["backtest"]
+        backtest_config["benchmark"] = D.list_instruments(instruments=D.instruments(market=self.market), as_list=True)
         strategy_config = {
             "class": "TopkDropoutStrategy",
             "module_path": "qlib.contrib.strategy.model_strategy",
@@ -172,98 +234,6 @@ class NestedDecisonExecutionWorkflow:
         for trade_decision in data_generator:
             print(trade_decision)
 
-    def _init_qlib_with_backend(self):
-        provider_uri_1min = HIGH_FREQ_CONFIG.get("provider_uri")
-        if not exists_qlib_data(provider_uri_1min):
-            print(f"Qlib data is not found in {provider_uri_1min}")
-            GetData().qlib_data(target_dir=provider_uri_1min, interval="1min", region=REG_CN)
-
-        # TODO: update latest data
-        provider_uri_day = "~/.qlib/qlib_data/cn_data"  # target_dir
-        if not exists_qlib_data(provider_uri_day):
-            print(f"Qlib data is not found in {provider_uri_day}")
-            GetData().qlib_data(target_dir=provider_uri_day, region=REG_CN)
-
-        provider_uri_map = {"1min": provider_uri_1min, "day": provider_uri_day}
-        client_config = {
-            "calendar_provider": {
-                "class": "LocalCalendarProvider",
-                "module_path": "qlib.data.data",
-                "kwargs": {
-                    "backend": {
-                        "class": "FileCalendarStorage",
-                        "module_path": "qlib.data.storage.file_storage",
-                        "kwargs": {"provider_uri_map": provider_uri_map},
-                    }
-                },
-            },
-            "feature_provider": {
-                "class": "LocalFeatureProvider",
-                "module_path": "qlib.data.data",
-                "kwargs": {
-                    "backend": {
-                        "class": "FileFeatureStorage",
-                        "module_path": "qlib.data.storage.file_storage",
-                        "kwargs": {"provider_uri_map": provider_uri_map},
-                    }
-                },
-            },
-        }
-        qlib.init(provider_uri=provider_uri_day, **client_config)
-
-    def _get_highfreq_config(self, model, dataset):
-
-        executor_config = self.port_analysis_config["executor"]
-        # update executor with hierarchical decison freq ["day", "1min"]
-        executor_config["kwargs"]["time_per_step"] = "day"
-        executor_config["kwargs"]["inner_executor"]["kwargs"]["time_per_step"] = "15min"
-        backtest_config = self.port_analysis_config["backtest"]
-
-        # yahoo highfreq data time
-        backtest_config["start_time"] = "2020-09-20"
-        backtest_config["end_time"] = "2021-01-20"
-
-        # update benchmark, yahoo data don't have SH000300
-        instruments = D.instruments(market="csi300")
-        instrument_list = D.list_instruments(instruments=instruments, as_list=True)
-        backtest_config["benchmark"] = instrument_list
-
-        # update exchange config
-        backtest_config["exchange_kwargs"]["freq"] = "1min"
-
-        # set strategy
-        strategy_config = {
-            "class": "TopkDropoutStrategy",
-            "module_path": "qlib.contrib.strategy.model_strategy",
-            "kwargs": {
-                "model": model,
-                "dataset": dataset,
-                "topk": 50,
-                "n_drop": 5,
-            },
-        }
-
-        return executor_config, strategy_config, backtest_config
-
-    def backtest_highfreq(self):
-        self._init_qlib_with_backend()
-        model = init_instance_by_config(self.task["model"])
-        dataset = init_instance_by_config(self.task["dataset"])
-        self._train_model(model, dataset)
-        executor_config, strategy_config, backtest_config = self._get_highfreq_config(model, dataset)
-
-        highfreq_port_analysis_config = {
-            "executor": executor_config,
-            "strategy": strategy_config,
-            "backtest": backtest_config,
-        }
-
-        with R.start(experiment_name="backtest_highfreq"):
-
-            recorder = R.get_recorder()
-            par = PortAnaRecord(recorder, highfreq_port_analysis_config, "day")
-            par.generate()
-
 
 if __name__ == "__main__":
-    fire.Fire(NestedDecisonExecutionWorkflow)
+    fire.Fire(NestedDecisionExecutionWorkflow)