Support Highfreq Backtest with the Model/Rule/RL Strategy

examples/nested_decision_execution/README.md

@@ -0,0 +1,30 @@
+# Nested Decision Execution
+
+This workflow is an example for nested decision execution in backtesting. Qlib supports nested decision execution in backtesting. It means that users can use different strategies to make trade decision in different frequencies.
+
+## Weekly Portfolio Generation and Daily Order Execution
+
+This workflow provides an example that uses a DropoutTopkStrategy (a strategy based on the daily frequency Lightgbm model) in weekly frequency for portfolio generation and uses SBBStrategyEMA (a rule-based strategy that uses EMA for decision-making) to execute orders in daily frequency. 
+
+### Usage
+
+Start backtesting by running the following command:
+```bash
+    python workflow.py backtest
+```
+
+Start collecting data by running the following command:
+```bash
+    python workflow.py collect_data
+```
+
+## Daily Portfolio Generation and Minutely Order Execution
+
+This workflow also provides a high-frequency example that uses a DropoutTopkStrategy for portfolio generation in daily frequency and uses SBBStrategyEMA to execute orders in minutely frequency. 
+
+### Usage
+
+Start backtesting by running the following command:
+```bash
+    python workflow.py backtest_highfreq
+```

examples/nested_decision_execution/workflow.py

@@ -0,0 +1,232 @@
+#  Copyright (c) Microsoft Corporation.
+#  Licensed under the MIT License.
+
+
+import qlib
+import fire
+from qlib.config import REG_CN, HIGH_FREQ_CONFIG
+from qlib.data import D
+from qlib.utils import exists_qlib_data, init_instance_by_config, flatten_dict
+from qlib.workflow import R
+from qlib.workflow.record_temp import SignalRecord, PortAnaRecord
+from qlib.tests.data import GetData
+from qlib.backtest import collect_data
+
+
+class NestedDecisionExecutionWorkflow:
+
+    market = "csi300"
+    benchmark = "SH000300"
+    data_handler_config = {
+        "start_time": "2008-01-01",
+        "end_time": "2020-12-31",
+        "fit_start_time": "2008-01-01",
+        "fit_end_time": "2014-12-31",
+        "instruments": market,
+    }
+
+    task = {
+        "model": {
+            "class": "LGBModel",
+            "module_path": "qlib.contrib.model.gbdt",
+            "kwargs": {
+                "loss": "mse",
+                "colsample_bytree": 0.8879,
+                "learning_rate": 0.0421,
+                "subsample": 0.8789,
+                "lambda_l1": 205.6999,
+                "lambda_l2": 580.9768,
+                "max_depth": 8,
+                "num_leaves": 210,
+                "num_threads": 20,
+            },
+        },
+        "dataset": {
+            "class": "DatasetH",
+            "module_path": "qlib.data.dataset",
+            "kwargs": {
+                "handler": {
+                    "class": "Alpha158",
+                    "module_path": "qlib.contrib.data.handler",
+                    "kwargs": data_handler_config,
+                },
+                "segments": {
+                    "train": ("2007-01-01", "2014-12-31"),
+                    "valid": ("2015-01-01", "2016-12-31"),
+                    "test": ("2020-01-01", "2020-12-31"),
+                },
+            },
+        },
+    }
+
+    port_analysis_config = {
+        "executor": {
+            "class": "NestedExecutor",
+            "module_path": "qlib.backtest.executor",
+            "kwargs": {
+                "time_per_step": "day",
+                "inner_executor": {
+                    "class": "NestedExecutor",
+                    "module_path": "qlib.backtest.executor",
+                    "kwargs": {
+                        "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": {
+                        "instruments": market,
+                        "freq": "1min",
+                    },
+                },
+                "track_data": True,
+                "generate_report": True,
+                "indicator_config": {
+                    "show_indicator": True,
+                },
+            },
+        },
+        "backtest": {
+            "start_time": "2020-01-01",
+            "end_time": "2020-12-31",
+            "account": 100000000,
+            "exchange_kwargs": {
+                "freq": "1min",
+                "limit_threshold": 0.095,
+                "deal_price": "close",
+                "open_cost": 0.0005,
+                "close_cost": 0.0015,
+                "min_cost": 5,
+            },
+        },
+    }
+
+    def _init_qlib(self):
+        """initialize qlib"""
+        # 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"):
+            R.log_params(**flatten_dict(self.task))
+            model.fit(dataset)
+            R.save_objects(**{"params.pkl": model})
+
+            # prediction
+            recorder = R.get_recorder()
+            sr = SignalRecord(model, dataset, recorder)
+            sr.generate()
+
+    def backtest(self):
+        self._init_qlib()
+        model = init_instance_by_config(self.task["model"])
+        dataset = init_instance_by_config(self.task["dataset"])
+        self._train_model(model, dataset)
+        strategy_config = {
+            "class": "TopkDropoutStrategy",
+            "module_path": "qlib.contrib.strategy.model_strategy",
+            "kwargs": {
+                "model": model,
+                "dataset": dataset,
+                "topk": 50,
+                "n_drop": 5,
+            },
+        }
+        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,
+                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"])
+        dataset = init_instance_by_config(self.task["dataset"])
+        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",
+            "kwargs": {
+                "model": model,
+                "dataset": dataset,
+                "topk": 50,
+                "n_drop": 5,
+            },
+        }
+        data_generator = collect_data(executor=executor_config, strategy=strategy_config, **backtest_config)
+        for trade_decision in data_generator:
+            print(trade_decision)
+
+
+if __name__ == "__main__":
+    fire.Fire(NestedDecisionExecutionWorkflow)

examples/rolling_process_data/workflow.py

@@ -21,7 +21,6 @@ class RollingDataWorkflow:
 
     def _init_qlib(self):
         """initialize qlib"""
-        # use yahoo_cn_1min data
         provider_uri = "~/.qlib/qlib_data/cn_data"  # target_dir
         GetData().qlib_data(target_dir=provider_uri, region=REG_CN, exists_skip=True)
         qlib.init(provider_uri=provider_uri, region=REG_CN)

examples/workflow_by_code.ipynb

@@ -66,7 +66,6 @@
     "from qlib.config import REG_CN\n",
     "from qlib.contrib.model.gbdt import LGBModel\n",
     "from qlib.contrib.data.handler import Alpha158\n",
-    "from qlib.contrib.strategy.strategy import TopkDropoutStrategy\n",
     "from qlib.contrib.evaluate import (\n",
     "    backtest as normal_backtest,\n",
     "    risk_analysis,\n",
@@ -197,27 +196,40 @@
     "# prediction, backtest & analysis\n",
     "###################################\n",
     "port_analysis_config = {\n",
+    "    \"executor\": {\n",
+    "        \"class\": \"SimulatorExecutor\",\n",
+    "        \"module_path\": \"qlib.backtest.executor\",\n",
+    "        \"kwargs\": {\n",
+    "            \"time_per_step\": \"day\",\n",
+    "            \"generate_report\": True,\n",
+    "        },\n",
+    "    },\n",
     "    \"strategy\": {\n",
     "        \"class\": \"TopkDropoutStrategy\",\n",
-    "        \"module_path\": \"qlib.contrib.strategy.strategy\",\n",
+    "        \"module_path\": \"qlib.contrib.strategy.model_strategy\",\n",
     "        \"kwargs\": {\n",
+    "            \"model\": model,\n",
+    "            \"dataset\": dataset,\n",
     "            \"topk\": 50,\n",
     "            \"n_drop\": 5,\n",
     "        },\n",
     "    },\n",
     "    \"backtest\": {\n",
-    "        \"verbose\": False,\n",
-    "        \"limit_threshold\": 0.095,\n",
+    "        \"start_time\": \"2017-01-01\",\n",
+    "        \"end_time\": \"2020-08-01\",\n",
     "        \"account\": 100000000,\n",
     "        \"benchmark\": benchmark,\n",
-    "        \"deal_price\": \"close\",\n",
-    "        \"open_cost\": 0.0005,\n",
-    "        \"close_cost\": 0.0015,\n",
-    "        \"min_cost\": 5,\n",
+    "        \"exchange_kwargs\": {\n",
+    "            \"freq\": \"day\",\n",
+    "            \"limit_threshold\": 0.095,\n",
+    "            \"deal_price\": \"close\",\n",
+    "            \"open_cost\": 0.0005,\n",
+    "            \"close_cost\": 0.0015,\n",
+    "            \"min_cost\": 5,\n",
+    "        },\n",
     "    },\n",
     "}\n",
     "\n",
-    "\n",
     "# backtest and analysis\n",
     "with R.start(experiment_name=\"backtest_analysis\"):\n",
     "    recorder = R.get_recorder(rid, experiment_name=\"train_model\")\n",
@@ -230,7 +242,7 @@
     "    sr.generate()\n",
     "\n",
     "    # backtest & analysis\n",
-    "    par = PortAnaRecord(recorder, port_analysis_config)\n",
+    "    par = PortAnaRecord(recorder, port_analysis_config, \"day\")\n",
     "    par.generate()\n"
    ]
   },
@@ -250,11 +262,12 @@
     "from qlib.contrib.report import analysis_model, analysis_position\n",
     "from qlib.data import D\n",
     "recorder = R.get_recorder(ba_rid, experiment_name=\"backtest_analysis\")\n",
+    "print(recorder)\n",
     "pred_df = recorder.load_object(\"pred.pkl\")\n",
     "pred_df_dates = pred_df.index.get_level_values(level='datetime')\n",
-    "report_normal_df = recorder.load_object(\"portfolio_analysis/report_normal.pkl\")\n",
-    "positions = recorder.load_object(\"portfolio_analysis/positions_normal.pkl\")\n",
-    "analysis_df = recorder.load_object(\"portfolio_analysis/port_analysis.pkl\")"
+    "report_normal_df = recorder.load_object(\"portfolio_analysis/report_normal_1day.pkl\")\n",
+    "positions = recorder.load_object(\"portfolio_analysis/positions_normal_1day.pkl\")\n",
+    "analysis_df = recorder.load_object(\"portfolio_analysis/port_analysis_1day.pkl\")"
    ]
   },
   {