Fix backtest

docs/component/strategy.rst

@@ -86,30 +86,79 @@ Usage & Example
 
 .. code-block:: python
 
-    from qlib.contrib.strategy.strategy import TopkDropoutStrategy
-    from qlib.contrib.evaluate import backtest
+    from pprint import pprint
+
+    import qlib
+    import pandas as pd
+    from qlib.utils.time import Freq
+    from qlib.utils import flatten_dict
+    from qlib.backtest import backtest, executor
+    from qlib.contrib.evaluate import risk_analysis
+    from qlib.contrib.strategy import TopkDropoutStrategy
+
+    # init qlib
+    qlib.init(provider_uri=<qlib data dir>)
+
+    CSI300_BENCH = "SH000300"
+    FREQ = "day"
     STRATEGY_CONFIG = {
         "topk": 50,
         "n_drop": 5,
+        # pred_score, pd.Series
+        "signal": pred_score,
+    }
+
+    EXECUTOR_CONFIG = {
+        "time_per_step": "day",
+        "generate_portfolio_metrics": True,
     }
-    BACKTEST_CONFIG = {
-        "limit_threshold": 0.095,
+
+    backtest_config = {
+        "start_time": "2017-01-01",
+        "end_time": "2020-08-01",
         "account": 100000000,
-        "benchmark": BENCHMARK,
-        "deal_price": "close",
-        "open_cost": 0.0005,
-        "close_cost": 0.0015,
-        "min_cost": 5,
-
+        "benchmark": CSI300_BENCH,
+        "exchange_kwargs": {
+            "freq": FREQ,
+            "limit_threshold": 0.095,
+            "deal_price": "close",
+            "open_cost": 0.0005,
+            "close_cost": 0.0015,
+            "min_cost": 5,
+        },
     }
-    # use default strategy
-    strategy = TopkDropoutStrategy(**STRATEGY_CONFIG)
 
-    # pred_score is the `prediction score` output by Model
-    report_normal, positions_normal = backtest(
-        pred_score, strategy=strategy, **BACKTEST_CONFIG
+    # strategy object
+    strategy_obj = TopkDropoutStrategy(**STRATEGY_CONFIG)
+    # executor object
+    executor_obj = executor.SimulatorExecutor(**EXECUTOR_CONFIG)
+    # backtest
+    portfolio_metric_dict, indicator_dict = backtest(executor=executor_obj, strategy=strategy_obj, **backtest_config)
+    analysis_freq = "{0}{1}".format(*Freq.parse(FREQ))
+    # backtest info
+    report_normal, positions_normal = portfolio_metric_dict.get(analysis_freq)
+
+    # analysis
+        analysis = dict()
+    analysis["excess_return_without_cost"] = risk_analysis(
+        report_normal["return"] - report_normal["bench"], freq=analysis_freq
+    )
+    analysis["excess_return_with_cost"] = risk_analysis(
+        report_normal["return"] - report_normal["bench"] - report_normal["cost"], freq=analysis_freq
     )
 
+    analysis_df = pd.concat(analysis)  # type: pd.DataFrame
+    # log metrics
+    analysis_dict = flatten_dict(analysis_df["risk"].unstack().T.to_dict())
+    # print out results
+    pprint(f"The following are analysis results of benchmark return({analysis_freq}).")
+    pprint(risk_analysis(report_normal["bench"], freq=analysis_freq))
+    pprint(f"The following are analysis results of the excess return without cost({analysis_freq}).")
+    pprint(analysis["excess_return_without_cost"])
+    pprint(f"The following are analysis results of the excess return with cost({analysis_freq}).")
+    pprint(analysis["excess_return_with_cost"])
+
+
 To know more about the `prediction score` `pred_score` output by ``Forecast Model``, please refer to `Forecast Model: Model Training & Prediction <model.html>`_.
 
 To know more about ``Intraday Trading``, please refer to `Intraday Trading: Model&Strategy Testing <backtest.html>`_.

qlib/backtest/__init__.py

@@ -187,7 +187,11 @@ def get_strategy_executor(
 
     common_infra = CommonInfrastructure(trade_account=trade_account, trade_exchange=trade_exchange)
     trade_strategy = init_instance_by_config(strategy, accept_types=BaseStrategy, common_infra=common_infra)
+    if isinstance(strategy, BaseStrategy):
+        trade_strategy.reset_common_infra(common_infra)
     trade_executor = init_instance_by_config(executor, accept_types=BaseExecutor, common_infra=common_infra)
+    if isinstance(executor, BaseExecutor):
+        trade_executor.reset_common_infra(common_infra)
 
     return trade_strategy, trade_executor
 

qlib/backtest/exchange.py

@@ -736,7 +736,11 @@ def _calc_trade_info_by_order(self, order, position: Position, dealt_order_amoun
 
         # TODO: the adjusted cost ratio can be overestimated as deal_amount will be clipped in the next steps
         trade_val = order.deal_amount * trade_price
-        adj_cost_ratio = self.impact_cost * (trade_val / total_trade_val) ** 2
+        assert trade_val > 1e-5, f"trade_val <= 1e-5, order info: {order}"
+        if not total_trade_val or np.isnan(total_trade_val):
+            adj_cost_ratio = self.impact_cost
+        else:
+            adj_cost_ratio = self.impact_cost * (trade_val / total_trade_val) ** 2
 
         if order.direction == Order.SELL:
             cost_ratio = self.close_cost + adj_cost_ratio

qlib/config.py

@@ -176,8 +176,6 @@ def set_conf_from_C(self, config_c):
     # if min_data_shift == 0, use default market time [9:30, 11:29, 1:00, 2:59]
     # if min_data_shift != 0, use shifted market time [9:30, 11:29, 1:00, 2:59] - shift*minute
     "min_data_shift": 0,
-    # whether to display the ops warning log, default False
-    "ops_warning_log": False,
 }
 
 MODE_CONF = {
@@ -272,6 +270,20 @@ def __init__(self, provider_uri: Union[str, Path, dict], mount_path: Union[str,
             self.provider_uri = provider_uri
             self.mount_path = mount_path
 
+        @staticmethod
+        def format_provider_uri(provider_uri: Union[str, dict, Path]) -> dict:
+            if provider_uri is None:
+                raise ValueError("provider_uri cannot be None")
+            if isinstance(provider_uri, (str, dict, Path)):
+                if not isinstance(provider_uri, dict):
+                    provider_uri = {QlibConfig.DEFAULT_FREQ: provider_uri}
+            else:
+                raise TypeError(f"provider_uri does not support {type(provider_uri)}")
+            for freq, _uri in provider_uri.items():
+                if QlibConfig.DataPathManager.get_uri_type(_uri) == QlibConfig.LOCAL_URI:
+                    provider_uri[freq] = str(Path(_uri).expanduser().resolve())
+            return provider_uri
+
         @staticmethod
         def get_uri_type(uri: Union[str, Path]):
             uri = uri if isinstance(uri, str) else str(uri.expanduser().resolve())
@@ -318,11 +330,7 @@ def dpm(self):
     def resolve_path(self):
         # resolve path
         _mount_path = self["mount_path"]
-        _provider_uri = self["provider_uri"]
-        if _provider_uri is None:
-            raise ValueError("provider_uri cannot be None")
-        if not isinstance(_provider_uri, dict):
-            _provider_uri = {self.DEFAULT_FREQ: _provider_uri}
+        _provider_uri = self.DataPathManager.format_provider_uri(self["provider_uri"])
         if not isinstance(_mount_path, dict):
             _mount_path = {_freq: _mount_path for _freq in _provider_uri.keys()}
 
@@ -331,10 +339,7 @@ def resolve_path(self):
         assert len(_miss_freq) == 0, f"mount_path is missing freq: {_miss_freq}"
 
         # resolve
-        for _freq, _uri in _provider_uri.items():
-            # provider_uri
-            if self.DataPathManager.get_uri_type(_uri) == QlibConfig.LOCAL_URI:
-                _provider_uri[_freq] = str(Path(_uri).expanduser().resolve())
+        for _freq in _provider_uri.keys():
             # mount_path
             _mount_path[_freq] = (
                 _mount_path[_freq]
@@ -344,20 +349,6 @@ def resolve_path(self):
         self["provider_uri"] = _provider_uri
         self["mount_path"] = _mount_path
 
-    def get_uri_type(self):
-        path = self["provider_uri"]
-        if isinstance(path, Path):
-            path = str(path)
-        is_win = re.match("^[a-zA-Z]:.*", path) is not None  # such as 'C:\\data', 'D:'
-        is_nfs_or_win = (
-            re.match("^[^/]+:.+", path) is not None
-        )  # such as 'host:/data/'   (User may define short hostname by themselves or use localhost)
-
-        if is_nfs_or_win and not is_win:
-            return QlibConfig.NFS_URI
-        else:
-            return QlibConfig.LOCAL_URI
-
     def set(self, default_conf: str = "client", **kwargs):
         """
         configure qlib based on the input parameters

qlib/contrib/report/analysis_position/report.py

@@ -171,20 +171,55 @@ def report_graph(report_df: pd.DataFrame, show_notebook: bool = True) -> [list,
 
             .. code-block:: python
 
-                from qlib.contrib.evaluate import backtest
+                import qlib
+                import pandas as pd
+                from qlib.utils.time import Freq
+                from qlib.utils import flatten_dict
+                from qlib.backtest import backtest, executor
+                from qlib.contrib.evaluate import risk_analysis
                 from qlib.contrib.strategy import TopkDropoutStrategy
 
-                # backtest parameters
-                bparas = {}
-                bparas['limit_threshold'] = 0.095
-                bparas['account'] = 1000000000
-
-                sparas = {}
-                sparas['topk'] = 50
-                sparas['n_drop'] = 230
-                strategy = TopkDropoutStrategy(**sparas)
-
-                report_normal_df, _ = backtest(pred_df, strategy, **bparas)
+                # init qlib
+                qlib.init(provider_uri=<qlib data dir>)
+
+                CSI300_BENCH = "SH000300"
+                FREQ = "day"
+                STRATEGY_CONFIG = {
+                    "topk": 50,
+                    "n_drop": 5,
+                    # pred_score, pd.Series
+                    "signal": pred_score,
+                }
+
+                EXECUTOR_CONFIG = {
+                    "time_per_step": "day",
+                    "generate_portfolio_metrics": True,
+                }
+
+                backtest_config = {
+                    "start_time": "2017-01-01",
+                    "end_time": "2020-08-01",
+                    "account": 100000000,
+                    "benchmark": CSI300_BENCH,
+                    "exchange_kwargs": {
+                        "freq": FREQ,
+                        "limit_threshold": 0.095,
+                        "deal_price": "close",
+                        "open_cost": 0.0005,
+                        "close_cost": 0.0015,
+                        "min_cost": 5,
+                    },
+                }
+
+                # strategy object
+                strategy_obj = TopkDropoutStrategy(**STRATEGY_CONFIG)
+                # executor object
+                executor_obj = executor.SimulatorExecutor(**EXECUTOR_CONFIG)
+                # backtest
+                portfolio_metric_dict, indicator_dict = backtest(executor=executor_obj, strategy=strategy_obj, **backtest_config)
+                analysis_freq = "{0}{1}".format(*Freq.parse(FREQ))
+                # backtest info
+                report_normal_df, positions_normal = portfolio_metric_dict.get(analysis_freq)
 
                 qcr.analysis_position.report_graph(report_normal_df)
 

qlib/contrib/report/analysis_position/risk_analysis.py

@@ -170,32 +170,64 @@ def risk_analysis_graph(
 
             .. code-block:: python
 
-                from qlib.contrib.evaluate import risk_analysis, backtest, long_short_backtest
+                import qlib
+                import pandas as pd
+                from qlib.utils.time import Freq
+                from qlib.utils import flatten_dict
+                from qlib.backtest import backtest, executor
+                from qlib.contrib.evaluate import risk_analysis
                 from qlib.contrib.strategy import TopkDropoutStrategy
-                from qlib.contrib.report import analysis_position
-
-                # backtest parameters
-                bparas = {}
-                bparas['limit_threshold'] = 0.095
-                bparas['account'] = 1000000000
-
-                sparas = {}
-                sparas['topk'] = 50
-                sparas['n_drop'] = 230
-                strategy = TopkDropoutStrategy(**sparas)
-
-                report_normal_df, positions = backtest(pred_df, strategy, **bparas)
-                # long_short_map = long_short_backtest(pred_df)
-                # report_long_short_df = pd.DataFrame(long_short_map)
 
+                # init qlib
+                qlib.init(provider_uri=<qlib data dir>)
+
+                CSI300_BENCH = "SH000300"
+                FREQ = "day"
+                STRATEGY_CONFIG = {
+                    "topk": 50,
+                    "n_drop": 5,
+                    # pred_score, pd.Series
+                    "signal": pred_score,
+                }
+
+                EXECUTOR_CONFIG = {
+                    "time_per_step": "day",
+                    "generate_portfolio_metrics": True,
+                }
+
+                backtest_config = {
+                    "start_time": "2017-01-01",
+                    "end_time": "2020-08-01",
+                    "account": 100000000,
+                    "benchmark": CSI300_BENCH,
+                    "exchange_kwargs": {
+                        "freq": FREQ,
+                        "limit_threshold": 0.095,
+                        "deal_price": "close",
+                        "open_cost": 0.0005,
+                        "close_cost": 0.0015,
+                        "min_cost": 5,
+                    },
+                }
+
+                # strategy object
+                strategy_obj = TopkDropoutStrategy(**STRATEGY_CONFIG)
+                # executor object
+                executor_obj = executor.SimulatorExecutor(**EXECUTOR_CONFIG)
+                # backtest
+                portfolio_metric_dict, indicator_dict = backtest(executor=executor_obj, strategy=strategy_obj, **backtest_config)
+                analysis_freq = "{0}{1}".format(*Freq.parse(FREQ))
+                # backtest info
+                report_normal_df, positions_normal = portfolio_metric_dict.get(analysis_freq)
                 analysis = dict()
-                # analysis['pred_long'] = risk_analysis(report_long_short_df['long'])
-                # analysis['pred_short'] = risk_analysis(report_long_short_df['short'])
-                # analysis['pred_long_short'] = risk_analysis(report_long_short_df['long_short'])
-                analysis['excess_return_without_cost'] = risk_analysis(report_normal_df['return'] - report_normal_df['bench'])
-                analysis['excess_return_with_cost'] = risk_analysis(report_normal_df['return'] - report_normal_df['bench'] - report_normal_df['cost'])
-                analysis_df = pd.concat(analysis)
-
+                analysis["excess_return_without_cost"] = risk_analysis(
+                    report_normal_df["return"] - report_normal_df["bench"], freq=analysis_freq
+                )
+                analysis["excess_return_with_cost"] = risk_analysis(
+                    report_normal_df["return"] - report_normal_df["bench"] - report_normal_df["cost"], freq=analysis_freq
+                )
+
+                analysis_df = pd.concat(analysis)  # type: pd.DataFrame
                 analysis_position.risk_analysis_graph(analysis_df, report_normal_df)
 
 

qlib/data/base.py

@@ -155,7 +155,7 @@ def load(self, instrument, start_index, end_index, freq):
         try:
             series = self._load_internal(instrument, start_index, end_index, freq)
         except Exception as e:
-            get_module_logger("data").error(
+            get_module_logger("data").debug(
                 f"Loading data error: instrument={instrument}, expression={str(self)}, "
                 f"start_index={start_index}, end_index={end_index}, freq={freq}. "
                 f"error info: {str(e)}"