split the factor processing out of factor analysis

alphamind/analysis/factoranalysis.py

@@ -14,38 +14,12 @@ from alphamind.data.winsorize import winsorize_normal
 from alphamind.portfolio.constraints import Constraints
 from alphamind.portfolio.longshortbulder import long_short_build
 from alphamind.portfolio.rankbuilder import rank_build
-from alphamind.portfolio.percentbuilder import percent_build
 from alphamind.portfolio.linearbuilder import linear_build
 from alphamind.portfolio.meanvariancebuilder import mean_variance_builder
-from alphamind.analysis.utilities import FDataPack
+from alphamind.data.processing import factor_processing
 from alphamind.settlement.simplesettle import simple_settle
 
 
-def build_portfolio(er: np.ndarray,
-                    builder: Optional[str] = 'long_short',
-                    **kwargs) -> np.ndarray:
-    builder = builder.lower()
-
-    if builder == 'ls' or builder == 'long_short':
-        return long_short_build(er, **kwargs).flatten()
-    elif builder == 'rank':
-        return rank_build(er, **kwargs).flatten()
-    elif builder == 'percent':
-        return percent_build(er, **kwargs).flatten()
-    elif builder == 'linear_prog' or builder == 'linear':
-        status, _, weight = linear_build(er, **kwargs)
-        if status != 'optimal':
-            raise ValueError('linear programming optimizer in status: {0}'.format(status))
-        else:
-            return weight
-    elif builder == 'mean_variance' or builder == 'mv':
-        status, _, weight = mean_variance_builder(er, **kwargs)
-        if status != 'optimal':
-            raise ValueError('mean variance optimizer in status: {0}'.format(status))
-        else:
-            return weight
-
-
 def factor_analysis(factors: pd.DataFrame,
                     factor_weights: np.ndarray,
                     industry: np.ndarray,
@@ -56,13 +30,7 @@ def factor_analysis(factors: pd.DataFrame,
                     is_tradable: Optional[np.ndarray] = None,
                     constraints: Optional[Constraints] = None,
                     method='risk_neutral',
-                    do_neutralize=True,
                     **kwargs) -> Tuple[pd.DataFrame, Optional[pd.DataFrame]]:
-    data_pack = FDataPack(raw_factors=factors.values,
-                          groups=industry,
-                          benchmark=benchmark,
-                          risk_exp=risk_exp,
-                          constraints=constraints)
 
     if 'pre_process' in kwargs:
         pre_process = kwargs['pre_process']
@@ -76,7 +44,7 @@ def factor_analysis(factors: pd.DataFrame,
     else:
         post_process = [standardize]
 
-    er = data_pack.factor_processing(pre_process, post_process, do_neutralize) @ factor_weights
+    er = factor_processing(factors.values, pre_process, risk_exp, post_process) @ factor_weights
 
     return er_analysis(er,
                        industry,
@@ -92,7 +60,7 @@ def factor_analysis(factors: pd.DataFrame,
 def er_analysis(er: np.ndarray,
                 industry: np.ndarray,
                 dx_return: np.ndarray,
-                constraints: Constraints,
+                constraints: Optional[Constraints]=None,
                 detail_analysis=True,
                 benchmark: Optional[np.ndarray] = None,
                 is_tradable: Optional[np.ndarray] = None,

alphamind/api.py

@@ -7,8 +7,10 @@ Created on 2017-8-16
 
 from alphamind.data.engines.sqlengine import SqlEngine
 from alphamind.analysis.factoranalysis import factor_analysis
+from alphamind.analysis.factoranalysis import er_analysis
 from alphamind.analysis.quantileanalysis import quantile_analysis
 from alphamind.data.engines.universe import Universe
+from alphamind.data.processing import factor_processing
 from alphamind.portfolio.constraints import Constraints
 
 from alphamind.data.engines.sqlengine import risk_styles
@@ -19,8 +21,10 @@ from alphamind.data.engines.sqlengine import macro_styles
 __all__ = [
     'SqlEngine',
     'factor_analysis',
+    'er_analysis',
     'quantile_analysis',
     'Universe',
+    'factor_processing',
     'Constraints',
     'risk_styles',
     'industry_styles',

alphamind/data/processing.py

+# -*- coding: utf-8 -*-
+"""
+Created on 2017-8-21
+
+@author: cheng.li
+"""
+
+from typing import Optional
+from typing import List
+import numpy as np
+from alphamind.data.neutralize import neutralize
+
+
+def factor_processing(raw_factors: np.ndarray,
+                      pre_process: Optional[List]=None,
+                      risk_exp: Optional[np.ndarray]=None,
+                      post_process: Optional[List]=None) -> np.ndarray:
+
+    new_factors = raw_factors
+
+    if pre_process:
+        for p in pre_process:
+            new_factors = p(new_factors)
+
+    if risk_exp is not None:
+        risk_exp = risk_exp[:, risk_exp.sum(axis=0) != 0]
+        new_factors = neutralize(risk_exp, new_factors)
+
+    if post_process:
+        for p in post_process:
+            new_factors = p(new_factors)
+
+    return new_factors