added benchmark to quantile analysis

alphamind/analysis/factoranalysis.py

@@ -59,9 +59,6 @@ def factor_analysis(factors: pd.DataFrame,
                     do_neutralize=True,
                     **kwargs) -> Tuple[pd.DataFrame, Optional[pd.DataFrame]]:
 
-    if risk_exp is not None:
-        risk_exp = risk_exp[:, risk_exp.sum(axis=0) != 0]
-
     data_pack = FDataPack(raw_factors=factors.values,
                           groups=industry,
                           benchmark=benchmark,

alphamind/analysis/quantileanalysis.py

@@ -40,7 +40,14 @@ def quantile_analysis(factors: pd.DataFrame,
                           risk_exp=risk_exp)
 
     er = data_pack.factor_processing(pre_process, post_process, do_neutralize) @ factor_weights
-    return q_anl_impl(er, n_bins, dx_return)
+    raw_return = q_anl_impl(er, n_bins, dx_return)
+
+    if benchmark is not None:
+        b_ret = np.dot(benchmark, dx_return)
+        b_total = benchmark.sum()
+        return raw_return * b_total - b_ret
+    else:
+        return raw_return
 
 
 def q_anl_impl(er: np.ndarray,

alphamind/analysis/utilities.py

@@ -63,6 +63,10 @@ class FDataPack(object):
             self.benchmark = benchmark.flatten()
         else:
             self.benchmark = None
+
+        if risk_exp is not None:
+            risk_exp = risk_exp[:, risk_exp.sum(axis=0) != 0]
+
         self.risk_exp = risk_exp
         self.constraints = constraints
         self.risk_names = risk_names

alphamind/tests/analysis/test_quantilieanalysis.py

@@ -24,6 +24,8 @@ class TestQuantileAnalysis(unittest.TestCase):
         self.x = np.random.randn(n, 5)
         self.x_w = np.random.randn(n_f)
         self.r = np.random.randn(n)
+        self.b_w = np.random.randint(0, 10, n)
+        self.b_w = self.b_w / float(self.b_w.sum())
         self.risk_exp = np.random.randn(n, 3)
         self.n_bins = 10
 
@@ -72,6 +74,27 @@ class TestQuantileAnalysis(unittest.TestCase):
         expected = q_anl_impl(er, self.n_bins, self.r)
         np.testing.assert_array_almost_equal(calculated, expected)
 
+    def test_quantile_analysis_with_benchmark(self):
+        f_df = pd.DataFrame(self.x)
+        calculated = quantile_analysis(f_df,
+                                       self.x_w,
+                                       self.r,
+                                       n_bins=self.n_bins,
+                                       do_neutralize=True,
+                                       benchmark=self.b_w,
+                                       risk_exp=self.risk_exp,
+                                       pre_process=[winsorize_normal, standardize],
+                                       post_process=[standardize])
+
+        er = self.x_w @ factor_processing(self.x,
+                                          [winsorize_normal, standardize],
+                                          self.risk_exp,
+                                          [standardize],
+                                          True).T
+        raw_er = q_anl_impl(er, self.n_bins, self.r)
+        expected = raw_er * self.b_w.sum() - np.dot(self.b_w, self.r)
+        np.testing.assert_array_almost_equal(calculated, expected)
+
 
 if __name__ == '__main__':
     unittest.main()