update models

alphamind/model/linearmodel.py

@@ -10,10 +10,40 @@ 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 PyFin.api import pyFinAssert
 from alphamind.model.modelbase import ModelBase
 from alphamind.utilities import alpha_logger
 
 
+class ConstLinearModel(ModelBase):
+
+    def __init__(self,
+                 features: np.ndarray=None,
+                 weights: np.ndarray=None):
+        super().__init__(features)
+        if features is not None and weights is not None:
+            pyFinAssert(len(features) == len(weights), ValueError, "length of features is not equal to length of weights")
+            self.weights = np.array(weights).flatten()
+
+    def fit(self, x: np.ndarray, y: np.ndarray):
+        pass
+
+    def predict(self, x):
+        return x @ self.weights
+
+    def save(self):
+        model_desc = super().save()
+        model_desc['weight'] = list(self.weights)
+        return model_desc
+
+    @classmethod
+    def load(cls, model_desc: dict):
+        obj_layout = cls()
+        obj_layout.features = model_desc['features']
+        obj_layout.weights = np.array(model_desc['weight'])
+        return obj_layout
+
+
 class LinearRegression(ModelBase):
 
     def __init__(self, features, fit_intercept: bool=False):
@@ -28,26 +58,40 @@ class LinearRegression(ModelBase):
 
     def save(self) -> dict:
         model_desc = super().save()
+        model_desc['internal_model'] = self.impl.__class__.__module__ + "." + self.impl.__class__.__name__,
         model_desc['desc'] = pickle.dumps(self.impl)
         model_desc['sklearn_version'] = sklearn_version
         return model_desc
 
-    def load(self, model_desc: dict):
-        super().load(model_desc)
+    def score(self) -> float:
+        return self.impl.score()
+
+    @classmethod
+    def load(cls, model_desc: dict):
+        obj_layout = cls()
+        obj_layout.features = model_desc['features']
 
         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']))
 
-        self.impl = pickle.loads(model_desc['desc'])
+        obj_layout.impl = pickle.loads(model_desc['desc'])
+        return obj_layout
 
 
 if __name__ == '__main__':
 
     import pprint
-    ls = LinearRegression(['a', 'b'])
+    ls = ConstLinearModel(np.array(['a', 'b']), np.array([0.5, 0.5]))
+
+    x = np.array([[0.2, 0.2],
+                  [0.1, 0.1],
+                  [0.3, 0.1]])
+
+    ls.predict(x)
+
+    desc = ls.save()
+    new_model = ConstLinearModel.load(desc)
 
-    model_desc = ls.save()
-    new_model = ls.load(model_desc)
-    pprint.pprint(model_desc)
+    pprint.pprint(new_model.save())

alphamind/model/modelbase.py

@@ -13,7 +13,7 @@ from alphamind.utilities import alpha_logger
 
 class ModelBase(metaclass=abc.ABCMeta):
 
-    def __init__(self, features: list):
+    def __init__(self, features: np.ndarray=None):
         self.features = features
 
     @abc.abstractmethod
@@ -30,14 +30,13 @@ class ModelBase(metaclass=abc.ABCMeta):
         if self.__class__.__module__ == '__main__':
             alpha_logger.warning("model is defined in a main module. The model_name may not be correct.")
 
-        model_desc = dict(internal_model=self.impl.__class__.__module__ + "." + self.impl.__class__.__name__,
-                          model_name=self.__class__.__module__ + "." + self.__class__.__name__,
+        model_desc = dict(model_name=self.__class__.__module__ + "." + self.__class__.__name__,
                           language='python',
                           timestamp=arrow.now().format(),
-                          features=self.features)
+                          features=list(self.features))
         return model_desc
 
-    @abc.abstractmethod
-    def load(self, model_desc: dict):
-        self.features = model_desc['features']
+    @abc.abstractclassmethod
+    def load(cls, model_desc: dict):
+        pass