We are currently solving the following issue within our repository. Here is the issue text:
--- BEGIN ISSUE ---
Missing `f` prefix on f-strings
Some strings looks like they're meant to be f-strings but are missing the `f` prefix meaning variable interpolation won't happen.

https://github.com/microsoft/qlib/blob/caea495f4087cabb15914123deca8acf94bbf4c6/qlib/contrib/eva/alpha.py#L126

I found this issue automatically. I'm a bot. Beep Boop 🦊. See other issues I found in your repo [here](https://codereview.doctor/microsoft/qlib)

--- END ISSUE ---

Below are some code segments, each from a relevant file. One or more of these files may contain bugs.
--- BEGIN FILES ---
Path: `qlib/contrib/eva/alpha.py`
Content:
```
1 """
2 Here is a batch of evaluation functions.
3 
4 The interface should be redesigned carefully in the future.
5 """
6 import pandas as pd
7 from typing import Tuple
8 from qlib import get_module_logger
9 from qlib.utils.paral import complex_parallel, DelayedDict
10 from joblib import Parallel, delayed
11 
12 
13 def calc_long_short_prec(
14     pred: pd.Series, label: pd.Series, date_col="datetime", quantile: float = 0.2, dropna=False, is_alpha=False
15 ) -> Tuple[pd.Series, pd.Series]:
16     """
17     calculate the precision for long and short operation
18 
19 
20     :param pred/label: index is **pd.MultiIndex**, index name is **[datetime, instruments]**; columns names is **[score]**.
21 
22             .. code-block:: python
23                                                   score
24                 datetime            instrument
25                 2020-12-01 09:30:00 SH600068    0.553634
26                                     SH600195    0.550017
27                                     SH600276    0.540321
28                                     SH600584    0.517297
29                                     SH600715    0.544674
30     label :
31         label
32     date_col :
33         date_col
34 
35     Returns
36     -------
37     (pd.Series, pd.Series)
38         long precision and short precision in time level
39     """
40     if is_alpha:
41         label = label - label.mean(level=date_col)
42     if int(1 / quantile) >= len(label.index.get_level_values(1).unique()):
43         raise ValueError("Need more instruments to calculate precision")
44 
45     df = pd.DataFrame({"pred": pred, "label": label})
46     if dropna:
47         df.dropna(inplace=True)
48 
49     group = df.groupby(level=date_col)
50 
51     N = lambda x: int(len(x) * quantile)
52     # find the top/low quantile of prediction and treat them as long and short target
53     long = group.apply(lambda x: x.nlargest(N(x), columns="pred").label).reset_index(level=0, drop=True)
54     short = group.apply(lambda x: x.nsmallest(N(x), columns="pred").label).reset_index(level=0, drop=True)
55 
56     groupll = long.groupby(date_col)
57     l_dom = groupll.apply(lambda x: x > 0)
58     l_c = groupll.count()
59 
60     groups = short.groupby(date_col)
61     s_dom = groups.apply(lambda x: x < 0)
62     s_c = groups.count()
63     return (l_dom.groupby(date_col).sum() / l_c), (s_dom.groupby(date_col).sum() / s_c)
64 
65 
66 def calc_long_short_return(
67     pred: pd.Series,
68     label: pd.Series,
69     date_col: str = "datetime",
70     quantile: float = 0.2,
71     dropna: bool = False,
72 ) -> Tuple[pd.Series, pd.Series]:
73     """
74     calculate long-short return
75 
76     Note:
77         `label` must be raw stock returns.
78 
79     Parameters
80     ----------
81     pred : pd.Series
82         stock predictions
83     label : pd.Series
84         stock returns
85     date_col : str
86         datetime index name
87     quantile : float
88         long-short quantile
89 
90     Returns
91     ----------
92     long_short_r : pd.Series
93         daily long-short returns
94     long_avg_r : pd.Series
95         daily long-average returns
96     """
97     df = pd.DataFrame({"pred": pred, "label": label})
98     if dropna:
99         df.dropna(inplace=True)
100     group = df.groupby(level=date_col)
101     N = lambda x: int(len(x) * quantile)
102     r_long = group.apply(lambda x: x.nlargest(N(x), columns="pred").label.mean())
103     r_short = group.apply(lambda x: x.nsmallest(N(x), columns="pred").label.mean())
104     r_avg = group.label.mean()
105     return (r_long - r_short) / 2, r_avg
106 
107 
108 def pred_autocorr(pred: pd.Series, lag=1, inst_col="instrument", date_col="datetime"):
109     """pred_autocorr.
110 
111     Limitation:
112     - If the datetime is not sequential densely, the correlation will be calulated based on adjacent dates. (some users may expected NaN)
113 
114     :param pred: pd.Series with following format
115                 instrument  datetime
116                 SH600000    2016-01-04   -0.000403
117                             2016-01-05   -0.000753
118                             2016-01-06   -0.021801
119                             2016-01-07   -0.065230
120                             2016-01-08   -0.062465
121     :type pred: pd.Series
122     :param lag:
123     """
124     if isinstance(pred, pd.DataFrame):
125         pred = pred.iloc[:, 0]
126         get_module_logger("pred_autocorr").warning("Only the first column in {pred.columns} of `pred` is kept")
127     pred_ustk = pred.sort_index().unstack(inst_col)
128     corr_s = {}
129     for (idx, cur), (_, prev) in zip(pred_ustk.iterrows(), pred_ustk.shift(lag).iterrows()):
130         corr_s[idx] = cur.corr(prev)
131     corr_s = pd.Series(corr_s).sort_index()
132     return corr_s
133 
134 
135 def pred_autocorr_all(pred_dict, n_jobs=-1, **kwargs):
136     """
137     calculate auto correlation for pred_dict
138 
139     Parameters
140     ----------
141     pred_dict : dict
142         A dict like {<method_name>:  <prediction>}
143     kwargs :
144         all these arguments will be passed into pred_autocorr
145     """
146     ac_dict = {}
147     for k, pred in pred_dict.items():
148         ac_dict[k] = delayed(pred_autocorr)(pred, **kwargs)
149     return complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), ac_dict)
150 
151 
152 def calc_ic(pred: pd.Series, label: pd.Series, date_col="datetime", dropna=False) -> (pd.Series, pd.Series):
153     """calc_ic.
154 
155     Parameters
156     ----------
157     pred :
158         pred
159     label :
160         label
161     date_col :
162         date_col
163 
164     Returns
165     -------
166     (pd.Series, pd.Series)
167         ic and rank ic
168     """
169     df = pd.DataFrame({"pred": pred, "label": label})
170     ic = df.groupby(date_col).apply(lambda df: df["pred"].corr(df["label"]))
171     ric = df.groupby(date_col).apply(lambda df: df["pred"].corr(df["label"], method="spearman"))
172     if dropna:
173         return ic.dropna(), ric.dropna()
174     else:
175         return ic, ric
176 
177 
178 def calc_all_ic(pred_dict_all, label, date_col="datetime", dropna=False, n_jobs=-1):
179     """calc_all_ic.
180 
181     Parameters
182     ----------
183     pred_dict_all :
184         A dict like {<method_name>:  <prediction>}
185     label:
186         A pd.Series of label values
187 
188     Returns
189     -------
190     {'Q2+IND_z': {'ic': <ic series like>
191                           2016-01-04   -0.057407
192                           ...
193                           2020-05-28    0.183470
194                           2020-05-29    0.171393
195                   'ric': <rank ic series like>
196                           2016-01-04   -0.040888
197                           ...
198                           2020-05-28    0.236665
199                           2020-05-29    0.183886
200                   }
201     ...}
202     """
203     pred_all_ics = {}
204     for k, pred in pred_dict_all.items():
205         pred_all_ics[k] = DelayedDict(["ic", "ric"], delayed(calc_ic)(pred, label, date_col=date_col, dropna=dropna))
206     pred_all_ics = complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), pred_all_ics)
207     return pred_all_ics
208
```
--- END FILES ---

Please first localize the bug based on the issue statement, and then generate a patch according to the `git diff` format fenced by three backticks.

Here is an example:

```diff
diff --git a/examples/server_async.py b/examples/server_async.py
--- a/examples/server_async.py
+++ b/examples/server_async.py
@@ -313,4 +313,4 @@
 
 
 if __name__ == "__main__":
-    asyncio.run(run_async_server("."), debug=True)
+    asyncio.run(run_async_server(), debug=True)
diff --git a/examples/server_sync.py b/examples/server_sync.py
--- a/examples/server_sync.py
+++ b/examples/server_sync.py
@@ -313,5 +313,5 @@
 
 
 if __name__ == "__main__":
-    server = run_sync_server(".")
+    server = run_sync_server()
     server.shutdown()

```

diff --git a/qlib/contrib/eva/alpha.py b/qlib/contrib/eva/alpha.py
--- a/qlib/contrib/eva/alpha.py
+++ b/qlib/contrib/eva/alpha.py
@@ -123,7 +123,7 @@
     """
     if isinstance(pred, pd.DataFrame):
         pred = pred.iloc[:, 0]
-        get_module_logger("pred_autocorr").warning("Only the first column in {pred.columns} of `pred` is kept")
+        get_module_logger("pred_autocorr").warning(f"Only the first column in {pred.columns} of `pred` is kept")
     pred_ustk = pred.sort_index().unstack(inst_col)
     corr_s = {}
     for (idx, cur), (_, prev) in zip(pred_ustk.iterrows(), pred_ustk.shift(lag).iterrows()):

{"golden_diff": "diff --git a/qlib/contrib/eva/alpha.py b/qlib/contrib/eva/alpha.py\n--- a/qlib/contrib/eva/alpha.py\n+++ b/qlib/contrib/eva/alpha.py\n@@ -123,7 +123,7 @@\n     \"\"\"\n     if isinstance(pred, pd.DataFrame):\n         pred = pred.iloc[:, 0]\n-        get_module_logger(\"pred_autocorr\").warning(\"Only the first column in {pred.columns} of `pred` is kept\")\n+        get_module_logger(\"pred_autocorr\").warning(f\"Only the first column in {pred.columns} of `pred` is kept\")\n     pred_ustk = pred.sort_index().unstack(inst_col)\n     corr_s = {}\n     for (idx, cur), (_, prev) in zip(pred_ustk.iterrows(), pred_ustk.shift(lag).iterrows()):\n", "issue": "Missing `f` prefix on f-strings\nSome strings looks like they're meant to be f-strings but are missing the `f` prefix meaning variable interpolation won't happen.\n\nhttps://github.com/microsoft/qlib/blob/caea495f4087cabb15914123deca8acf94bbf4c6/qlib/contrib/eva/alpha.py#L126\n\nI found this issue automatically. I'm a bot. Beep Boop \ud83e\udd8a. See other issues I found in your repo [here](https://codereview.doctor/microsoft/qlib)\n", "before_files": [{"content": "\"\"\"\nHere is a batch of evaluation functions.\n\nThe interface should be redesigned carefully in the future.\n\"\"\"\nimport pandas as pd\nfrom typing import Tuple\nfrom qlib import get_module_logger\nfrom qlib.utils.paral import complex_parallel, DelayedDict\nfrom joblib import Parallel, delayed\n\n\ndef calc_long_short_prec(\n    pred: pd.Series, label: pd.Series, date_col=\"datetime\", quantile: float = 0.2, dropna=False, is_alpha=False\n) -> Tuple[pd.Series, pd.Series]:\n    \"\"\"\n    calculate the precision for long and short operation\n\n\n    :param pred/label: index is **pd.MultiIndex**, index name is **[datetime, instruments]**; columns names is **[score]**.\n\n            .. code-block:: python\n                                                  score\n                datetime            instrument\n                2020-12-01 09:30:00 SH600068    0.553634\n                                    SH600195    0.550017\n                                    SH600276    0.540321\n                                    SH600584    0.517297\n                                    SH600715    0.544674\n    label :\n        label\n    date_col :\n        date_col\n\n    Returns\n    -------\n    (pd.Series, pd.Series)\n        long precision and short precision in time level\n    \"\"\"\n    if is_alpha:\n        label = label - label.mean(level=date_col)\n    if int(1 / quantile) >= len(label.index.get_level_values(1).unique()):\n        raise ValueError(\"Need more instruments to calculate precision\")\n\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    if dropna:\n        df.dropna(inplace=True)\n\n    group = df.groupby(level=date_col)\n\n    N = lambda x: int(len(x) * quantile)\n    # find the top/low quantile of prediction and treat them as long and short target\n    long = group.apply(lambda x: x.nlargest(N(x), columns=\"pred\").label).reset_index(level=0, drop=True)\n    short = group.apply(lambda x: x.nsmallest(N(x), columns=\"pred\").label).reset_index(level=0, drop=True)\n\n    groupll = long.groupby(date_col)\n    l_dom = groupll.apply(lambda x: x > 0)\n    l_c = groupll.count()\n\n    groups = short.groupby(date_col)\n    s_dom = groups.apply(lambda x: x < 0)\n    s_c = groups.count()\n    return (l_dom.groupby(date_col).sum() / l_c), (s_dom.groupby(date_col).sum() / s_c)\n\n\ndef calc_long_short_return(\n    pred: pd.Series,\n    label: pd.Series,\n    date_col: str = \"datetime\",\n    quantile: float = 0.2,\n    dropna: bool = False,\n) -> Tuple[pd.Series, pd.Series]:\n    \"\"\"\n    calculate long-short return\n\n    Note:\n        `label` must be raw stock returns.\n\n    Parameters\n    ----------\n    pred : pd.Series\n        stock predictions\n    label : pd.Series\n        stock returns\n    date_col : str\n        datetime index name\n    quantile : float\n        long-short quantile\n\n    Returns\n    ----------\n    long_short_r : pd.Series\n        daily long-short returns\n    long_avg_r : pd.Series\n        daily long-average returns\n    \"\"\"\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    if dropna:\n        df.dropna(inplace=True)\n    group = df.groupby(level=date_col)\n    N = lambda x: int(len(x) * quantile)\n    r_long = group.apply(lambda x: x.nlargest(N(x), columns=\"pred\").label.mean())\n    r_short = group.apply(lambda x: x.nsmallest(N(x), columns=\"pred\").label.mean())\n    r_avg = group.label.mean()\n    return (r_long - r_short) / 2, r_avg\n\n\ndef pred_autocorr(pred: pd.Series, lag=1, inst_col=\"instrument\", date_col=\"datetime\"):\n    \"\"\"pred_autocorr.\n\n    Limitation:\n    - If the datetime is not sequential densely, the correlation will be calulated based on adjacent dates. (some users may expected NaN)\n\n    :param pred: pd.Series with following format\n                instrument  datetime\n                SH600000    2016-01-04   -0.000403\n                            2016-01-05   -0.000753\n                            2016-01-06   -0.021801\n                            2016-01-07   -0.065230\n                            2016-01-08   -0.062465\n    :type pred: pd.Series\n    :param lag:\n    \"\"\"\n    if isinstance(pred, pd.DataFrame):\n        pred = pred.iloc[:, 0]\n        get_module_logger(\"pred_autocorr\").warning(\"Only the first column in {pred.columns} of `pred` is kept\")\n    pred_ustk = pred.sort_index().unstack(inst_col)\n    corr_s = {}\n    for (idx, cur), (_, prev) in zip(pred_ustk.iterrows(), pred_ustk.shift(lag).iterrows()):\n        corr_s[idx] = cur.corr(prev)\n    corr_s = pd.Series(corr_s).sort_index()\n    return corr_s\n\n\ndef pred_autocorr_all(pred_dict, n_jobs=-1, **kwargs):\n    \"\"\"\n    calculate auto correlation for pred_dict\n\n    Parameters\n    ----------\n    pred_dict : dict\n        A dict like {<method_name>:  <prediction>}\n    kwargs :\n        all these arguments will be passed into pred_autocorr\n    \"\"\"\n    ac_dict = {}\n    for k, pred in pred_dict.items():\n        ac_dict[k] = delayed(pred_autocorr)(pred, **kwargs)\n    return complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), ac_dict)\n\n\ndef calc_ic(pred: pd.Series, label: pd.Series, date_col=\"datetime\", dropna=False) -> (pd.Series, pd.Series):\n    \"\"\"calc_ic.\n\n    Parameters\n    ----------\n    pred :\n        pred\n    label :\n        label\n    date_col :\n        date_col\n\n    Returns\n    -------\n    (pd.Series, pd.Series)\n        ic and rank ic\n    \"\"\"\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    ic = df.groupby(date_col).apply(lambda df: df[\"pred\"].corr(df[\"label\"]))\n    ric = df.groupby(date_col).apply(lambda df: df[\"pred\"].corr(df[\"label\"], method=\"spearman\"))\n    if dropna:\n        return ic.dropna(), ric.dropna()\n    else:\n        return ic, ric\n\n\ndef calc_all_ic(pred_dict_all, label, date_col=\"datetime\", dropna=False, n_jobs=-1):\n    \"\"\"calc_all_ic.\n\n    Parameters\n    ----------\n    pred_dict_all :\n        A dict like {<method_name>:  <prediction>}\n    label:\n        A pd.Series of label values\n\n    Returns\n    -------\n    {'Q2+IND_z': {'ic': <ic series like>\n                          2016-01-04   -0.057407\n                          ...\n                          2020-05-28    0.183470\n                          2020-05-29    0.171393\n                  'ric': <rank ic series like>\n                          2016-01-04   -0.040888\n                          ...\n                          2020-05-28    0.236665\n                          2020-05-29    0.183886\n                  }\n    ...}\n    \"\"\"\n    pred_all_ics = {}\n    for k, pred in pred_dict_all.items():\n        pred_all_ics[k] = DelayedDict([\"ic\", \"ric\"], delayed(calc_ic)(pred, label, date_col=date_col, dropna=dropna))\n    pred_all_ics = complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), pred_all_ics)\n    return pred_all_ics\n", "path": "qlib/contrib/eva/alpha.py"}], "after_files": [{"content": "\"\"\"\nHere is a batch of evaluation functions.\n\nThe interface should be redesigned carefully in the future.\n\"\"\"\nimport pandas as pd\nfrom typing import Tuple\nfrom qlib import get_module_logger\nfrom qlib.utils.paral import complex_parallel, DelayedDict\nfrom joblib import Parallel, delayed\n\n\ndef calc_long_short_prec(\n    pred: pd.Series, label: pd.Series, date_col=\"datetime\", quantile: float = 0.2, dropna=False, is_alpha=False\n) -> Tuple[pd.Series, pd.Series]:\n    \"\"\"\n    calculate the precision for long and short operation\n\n\n    :param pred/label: index is **pd.MultiIndex**, index name is **[datetime, instruments]**; columns names is **[score]**.\n\n            .. code-block:: python\n                                                  score\n                datetime            instrument\n                2020-12-01 09:30:00 SH600068    0.553634\n                                    SH600195    0.550017\n                                    SH600276    0.540321\n                                    SH600584    0.517297\n                                    SH600715    0.544674\n    label :\n        label\n    date_col :\n        date_col\n\n    Returns\n    -------\n    (pd.Series, pd.Series)\n        long precision and short precision in time level\n    \"\"\"\n    if is_alpha:\n        label = label - label.mean(level=date_col)\n    if int(1 / quantile) >= len(label.index.get_level_values(1).unique()):\n        raise ValueError(\"Need more instruments to calculate precision\")\n\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    if dropna:\n        df.dropna(inplace=True)\n\n    group = df.groupby(level=date_col)\n\n    N = lambda x: int(len(x) * quantile)\n    # find the top/low quantile of prediction and treat them as long and short target\n    long = group.apply(lambda x: x.nlargest(N(x), columns=\"pred\").label).reset_index(level=0, drop=True)\n    short = group.apply(lambda x: x.nsmallest(N(x), columns=\"pred\").label).reset_index(level=0, drop=True)\n\n    groupll = long.groupby(date_col)\n    l_dom = groupll.apply(lambda x: x > 0)\n    l_c = groupll.count()\n\n    groups = short.groupby(date_col)\n    s_dom = groups.apply(lambda x: x < 0)\n    s_c = groups.count()\n    return (l_dom.groupby(date_col).sum() / l_c), (s_dom.groupby(date_col).sum() / s_c)\n\n\ndef calc_long_short_return(\n    pred: pd.Series,\n    label: pd.Series,\n    date_col: str = \"datetime\",\n    quantile: float = 0.2,\n    dropna: bool = False,\n) -> Tuple[pd.Series, pd.Series]:\n    \"\"\"\n    calculate long-short return\n\n    Note:\n        `label` must be raw stock returns.\n\n    Parameters\n    ----------\n    pred : pd.Series\n        stock predictions\n    label : pd.Series\n        stock returns\n    date_col : str\n        datetime index name\n    quantile : float\n        long-short quantile\n\n    Returns\n    ----------\n    long_short_r : pd.Series\n        daily long-short returns\n    long_avg_r : pd.Series\n        daily long-average returns\n    \"\"\"\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    if dropna:\n        df.dropna(inplace=True)\n    group = df.groupby(level=date_col)\n    N = lambda x: int(len(x) * quantile)\n    r_long = group.apply(lambda x: x.nlargest(N(x), columns=\"pred\").label.mean())\n    r_short = group.apply(lambda x: x.nsmallest(N(x), columns=\"pred\").label.mean())\n    r_avg = group.label.mean()\n    return (r_long - r_short) / 2, r_avg\n\n\ndef pred_autocorr(pred: pd.Series, lag=1, inst_col=\"instrument\", date_col=\"datetime\"):\n    \"\"\"pred_autocorr.\n\n    Limitation:\n    - If the datetime is not sequential densely, the correlation will be calulated based on adjacent dates. (some users may expected NaN)\n\n    :param pred: pd.Series with following format\n                instrument  datetime\n                SH600000    2016-01-04   -0.000403\n                            2016-01-05   -0.000753\n                            2016-01-06   -0.021801\n                            2016-01-07   -0.065230\n                            2016-01-08   -0.062465\n    :type pred: pd.Series\n    :param lag:\n    \"\"\"\n    if isinstance(pred, pd.DataFrame):\n        pred = pred.iloc[:, 0]\n        get_module_logger(\"pred_autocorr\").warning(f\"Only the first column in {pred.columns} of `pred` is kept\")\n    pred_ustk = pred.sort_index().unstack(inst_col)\n    corr_s = {}\n    for (idx, cur), (_, prev) in zip(pred_ustk.iterrows(), pred_ustk.shift(lag).iterrows()):\n        corr_s[idx] = cur.corr(prev)\n    corr_s = pd.Series(corr_s).sort_index()\n    return corr_s\n\n\ndef pred_autocorr_all(pred_dict, n_jobs=-1, **kwargs):\n    \"\"\"\n    calculate auto correlation for pred_dict\n\n    Parameters\n    ----------\n    pred_dict : dict\n        A dict like {<method_name>:  <prediction>}\n    kwargs :\n        all these arguments will be passed into pred_autocorr\n    \"\"\"\n    ac_dict = {}\n    for k, pred in pred_dict.items():\n        ac_dict[k] = delayed(pred_autocorr)(pred, **kwargs)\n    return complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), ac_dict)\n\n\ndef calc_ic(pred: pd.Series, label: pd.Series, date_col=\"datetime\", dropna=False) -> (pd.Series, pd.Series):\n    \"\"\"calc_ic.\n\n    Parameters\n    ----------\n    pred :\n        pred\n    label :\n        label\n    date_col :\n        date_col\n\n    Returns\n    -------\n    (pd.Series, pd.Series)\n        ic and rank ic\n    \"\"\"\n    df = pd.DataFrame({\"pred\": pred, \"label\": label})\n    ic = df.groupby(date_col).apply(lambda df: df[\"pred\"].corr(df[\"label\"]))\n    ric = df.groupby(date_col).apply(lambda df: df[\"pred\"].corr(df[\"label\"], method=\"spearman\"))\n    if dropna:\n        return ic.dropna(), ric.dropna()\n    else:\n        return ic, ric\n\n\ndef calc_all_ic(pred_dict_all, label, date_col=\"datetime\", dropna=False, n_jobs=-1):\n    \"\"\"calc_all_ic.\n\n    Parameters\n    ----------\n    pred_dict_all :\n        A dict like {<method_name>:  <prediction>}\n    label:\n        A pd.Series of label values\n\n    Returns\n    -------\n    {'Q2+IND_z': {'ic': <ic series like>\n                          2016-01-04   -0.057407\n                          ...\n                          2020-05-28    0.183470\n                          2020-05-29    0.171393\n                  'ric': <rank ic series like>\n                          2016-01-04   -0.040888\n                          ...\n                          2020-05-28    0.236665\n                          2020-05-29    0.183886\n                  }\n    ...}\n    \"\"\"\n    pred_all_ics = {}\n    for k, pred in pred_dict_all.items():\n        pred_all_ics[k] = DelayedDict([\"ic\", \"ric\"], delayed(calc_ic)(pred, label, date_col=date_col, dropna=dropna))\n    pred_all_ics = complex_parallel(Parallel(n_jobs=n_jobs, verbose=10), pred_all_ics)\n    return pred_all_ics\n", "path": "qlib/contrib/eva/alpha.py"}]}