update models

alphamind/model/linearmodel.py

@@ -6,14 +6,11 @@ Created on 2017-5-10
 """
 
 import numpy as np
-from distutils.version import LooseVersion
-from sklearn import __version__ as sklearn_version
 from sklearn.linear_model import LinearRegression as LinearRegressionImpl
 from sklearn.linear_model import Lasso
 from sklearn.linear_model import LogisticRegression as LogisticRegressionImpl
 from PyFin.api import pyFinAssert
-from alphamind.model.modelbase import ModelBase
-from alphamind.utilities import alpha_logger
+from alphamind.model.modelbase import create_model_base
 
 
 class ConstLinearModelImpl(object):
@@ -35,7 +32,7 @@ class ConstLinearModelImpl(object):
         return 1. - sse / ssto
 
 
-class ConstLinearModel(ModelBase):
+class ConstLinearModel(create_model_base()):
 
     def __init__(self,
                  features=None,
@@ -63,7 +60,7 @@ class ConstLinearModel(ModelBase):
         return self.impl.weights.tolist()
 
 
-class LinearRegression(ModelBase):
+class LinearRegression(create_model_base('sklearn')):
 
     def __init__(self, features=None, fit_intercept: bool = False, fit_target=None, **kwargs):
         super().__init__(features=features, fit_target=fit_target)
@@ -71,26 +68,15 @@ class LinearRegression(ModelBase):
 
     def save(self) -> dict:
         model_desc = super().save()
-        model_desc['sklearn_version'] = sklearn_version
         model_desc['weight'] = self.impl.coef_.tolist()
         return model_desc
 
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(sklearn_version) < LooseVersion(model_desc['sklearn_version']):
-            alpha_logger.warning('Current sklearn version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(sklearn_version,
-                                                                             model_desc['sklearn_version']))
-        return obj_layout
-
     @property
     def weights(self):
         return self.impl.coef_.tolist()
 
 
-class LassoRegression(ModelBase):
+class LassoRegression(create_model_base('sklearn')):
 
     def __init__(self, alpha=0.01, features=None, fit_intercept: bool = False, fit_target=None, **kwargs):
         super().__init__(features=features, fit_target=fit_target)
@@ -98,26 +84,15 @@ class LassoRegression(ModelBase):
 
     def save(self) -> dict:
         model_desc = super().save()
-        model_desc['sklearn_version'] = sklearn_version
         model_desc['weight'] = self.impl.coef_.tolist()
         return model_desc
 
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(sklearn_version) < LooseVersion(model_desc['sklearn_version']):
-            alpha_logger.warning('Current sklearn version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(sklearn_version,
-                                                                             model_desc['sklearn_version']))
-        return obj_layout
-
     @property
     def weights(self):
         return self.impl.coef_.tolist()
 
 
-class LogisticRegression(ModelBase):
+class LogisticRegression(create_model_base('sklearn')):
 
     def __init__(self, features=None, fit_intercept: bool = False, fit_target=None, **kwargs):
         super().__init__(features=features, fit_target=fit_target)
@@ -125,20 +100,9 @@ class LogisticRegression(ModelBase):
 
     def save(self) -> dict:
         model_desc = super().save()
-        model_desc['sklearn_version'] = sklearn_version
         model_desc['weight'] = self.impl.coef_.tolist()
         return model_desc
 
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(sklearn_version) < LooseVersion(model_desc['sklearn_version']):
-            alpha_logger.warning('Current sklearn version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(sklearn_version,
-                                                                             model_desc['sklearn_version']))
-        return obj_layout
-
     @property
     def weights(self):
         return self.impl.coef_.tolist()

alphamind/model/modelbase.py

@@ -6,10 +6,13 @@ Created on 2017-9-4
 """
 
 import abc
+from distutils.version import LooseVersion
 import arrow
 import numpy as np
 import pandas as pd
 from simpleutils.miscellaneous import list_eq
+from sklearn import __version__ as sklearn_version
+from xgboost import __version__ as xgbboot_version
 from alphamind.utilities import alpha_logger
 from alphamind.utilities import encode
 from alphamind.utilities import decode
@@ -84,3 +87,39 @@ class ModelBase(metaclass=abc.ABCMeta):
             obj_layout.fit_target = None
         return obj_layout
 
+
+def create_model_base(party_name=None):
+    if not party_name:
+        return ModelBase
+    else:
+        class ExternalLibBase(ModelBase):
+            _lib_name = party_name
+
+            def save(self) -> dict:
+                model_desc = super().save()
+                if self._lib_name == 'sklearn':
+                    model_desc[self._lib_name] = sklearn_version
+                elif self._lib_name == 'xgboost':
+                    model_desc[self._lib_name] = xgbboot_version
+                else:
+                    raise ValueError("3rd party lib name ({0}) is not recognized".format(self._lib_name))
+                return model_desc
+
+            @classmethod
+            def load(cls, model_desc: dict):
+                obj_layout = super().load(model_desc)
+
+                if cls._lib_name == 'sklearn':
+                    current_version = sklearn_version
+                elif cls._lib_name == 'xgboost':
+                    current_version = xgbboot_version
+                else:
+                    raise ValueError("3rd party lib name ({0}) is not recognized".format(cls._lib_name))
+
+                if LooseVersion(current_version) < LooseVersion(model_desc[cls._lib_name]):
+                    alpha_logger.warning('Current {2} version {0} is lower than the model version {1}. '
+                                         'Loaded model may work incorrectly.'.format(sklearn_version,
+                                                                                     model_desc[cls._lib_name],
+                                                                                     cls._lib_name))
+                return obj_layout
+        return ExternalLibBase

alphamind/model/svm.py

+# -*- coding: utf-8 -*-
+"""
+Created on 2018-7-9
+
+@author: cheng.li
+"""
+
+from sklearn.svm import NuSVR
+from alphamind.model.modelbase import create_model_base
+
+
+class NvSVRModel(create_model_base('sklearn')):
+
+    def __init__(self,
+                 features=None,
+                 fit_target=None,
+                 **kwargs):
+        super().__init__(features=features, fit_target=fit_target)
+        self.impl = NuSVR(**kwargs)

alphamind/model/treemodel.py

@@ -9,7 +9,6 @@ from distutils.version import LooseVersion
 import arrow
 import numpy as np
 import pandas as pd
-from sklearn import __version__ as sklearn_version
 from sklearn.ensemble import RandomForestRegressor as RandomForestRegressorImpl
 from sklearn.ensemble import RandomForestClassifier as RandomForestClassifierImpl
 from sklearn.model_selection import train_test_split
@@ -17,11 +16,11 @@ import xgboost as xgb
 from xgboost import __version__ as xgbboot_version
 from xgboost import XGBRegressor as XGBRegressorImpl
 from xgboost import XGBClassifier as XGBClassifierImpl
-from alphamind.model.modelbase import ModelBase
+from alphamind.model.modelbase import create_model_base
 from alphamind.utilities import alpha_logger
 
 
-class RandomForestRegressor(ModelBase):
+class RandomForestRegressor(create_model_base('sklearn')):
 
     def __init__(self,
                  n_estimators: int=100,
@@ -34,27 +33,12 @@ class RandomForestRegressor(ModelBase):
                                               max_features=max_features,
                                               **kwargs)
 
-    def save(self) -> dict:
-        model_desc = super().save()
-        model_desc['sklearn_version'] = sklearn_version
-        return model_desc
-
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(sklearn_version) < LooseVersion(model_desc['sklearn_version']):
-            alpha_logger.warning('Current sklearn version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(sklearn_version,
-                                                                             model_desc['sklearn_version']))
-        return obj_layout
-
     @property
     def importances(self):
         return self.impl.feature_importances_.tolist()
 
 
-class RandomForestClassifier(ModelBase):
+class RandomForestClassifier(create_model_base('sklearn')):
 
     def __init__(self,
                  n_estimators: int=100,
@@ -67,27 +51,12 @@ class RandomForestClassifier(ModelBase):
                                                max_features=max_features,
                                                **kwargs)
 
-    def save(self) -> dict:
-        model_desc = super().save()
-        model_desc['sklearn_version'] = sklearn_version
-        return model_desc
-
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(sklearn_version) < LooseVersion(model_desc['sklearn_version']):
-            alpha_logger.warning('Current sklearn version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(sklearn_version,
-                                                                             model_desc['sklearn_version']))
-        return obj_layout
-
     @property
     def importances(self):
         return self.impl.feature_importances_.tolist()
 
 
-class XGBRegressor(ModelBase):
+class XGBRegressor(create_model_base('xgboost')):
 
     def __init__(self,
                  n_estimators: int=100,
@@ -104,27 +73,12 @@ class XGBRegressor(ModelBase):
                                      n_jobs=n_jobs,
                                      **kwargs)
 
-    def save(self) -> dict:
-        model_desc = super().save()
-        model_desc['xgbboot_version'] = xgbboot_version
-        return model_desc
-
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(xgbboot_version) < LooseVersion(model_desc['xgbboot_version']):
-            alpha_logger.warning('Current xgboost version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(xgbboot_version,
-                                                                             model_desc['xgbboot_version']))
-        return obj_layout
-
     @property
     def importances(self):
         return self.impl.feature_importances_.tolist()
 
 
-class XGBClassifier(ModelBase):
+class XGBClassifier(create_model_base('xgboost')):
 
     def __init__(self,
                  n_estimators: int=100,
@@ -141,27 +95,12 @@ class XGBClassifier(ModelBase):
                                       n_jobs=n_jobs,
                                       **kwargs)
 
-    def save(self) -> dict:
-        model_desc = super().save()
-        model_desc['xgbboot_version'] = xgbboot_version
-        return model_desc
-
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(xgbboot_version) < LooseVersion(model_desc['xgbboot_version']):
-            alpha_logger.warning('Current xgboost version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(xgbboot_version,
-                                                                             model_desc['xgbboot_version']))
-        return obj_layout
-
     @property
     def importances(self):
         return self.impl.feature_importances_.tolist()
 
 
-class XGBTrainer(ModelBase):
+class XGBTrainer(create_model_base('xgboost')):
 
     def __init__(self,
                  objective='binary:logistic',
@@ -226,21 +165,6 @@ class XGBTrainer(ModelBase):
         d_predict = xgb.DMatrix(x[self.features].values)
         return self.impl.predict(d_predict)
 
-    def save(self) -> dict:
-        model_desc = super().save()
-        model_desc['xgbboot_version'] = xgbboot_version
-        return model_desc
-
-    @classmethod
-    def load(cls, model_desc: dict):
-        obj_layout = super().load(model_desc)
-
-        if LooseVersion(xgbboot_version) < LooseVersion(model_desc['xgbboot_version']):
-            alpha_logger.warning('Current xgboost version {0} is lower than the model version {1}. '
-                                 'Loaded model may work incorrectly.'.format(xgbboot_version,
-                                                                             model_desc['xgbboot_version']))
-        return obj_layout
-
     @property
     def importances(self):
         imps = self.impl.get_fscore().items()