* ModelFactory with model family

* Generalize json encoder for pandas
* Join decorators into one

Author: lopezco

python/factory.py

@@ -3,6 +3,7 @@
 
 
 class ModelFactory(object):
+    available_models = (SklearnModel, )
 
     @classmethod
     def create_model(cls, model_name, model_type='SKLEARN_MODEL'):
@@ -17,5 +18,6 @@ def create_model(cls, model_name, model_type='SKLEARN_MODEL'):
             raise RuntimeError("Model {} not found".format(model_path))
         else:
             # Model found! now create an instance
-            if model_type == 'SKLEARN_MODEL':
-                return SklearnModel(model_path)
+            for model_class in cls.available_models:
+                if model_class.family == model_type:
+                    return model_class(model_path)

python/model/base.py

@@ -17,29 +17,25 @@
     SHAP_AVAILABLE = True
 
 
-def _check_readiness(func):
-    @wraps(func)
-    def wrapper(*args, **kwargs):
-        self = args[0]
-        if self.is_ready():
-            return func(*args, **kwargs)
-        else:
-            raise RuntimeError('Model is not ready yet.')
-    return wrapper
-
-
-def _check_task(task):
+def _check(ready=True, explainable=False, task=None):
     def actual_decorator(func):
         @wraps(func)
         def wrapper(*args, **kwargs):
-            self_task = args[0].task_type()
-            strict = task.upper() != 'CLASSIFICATION'
-            target_task = Task(task)
-            if (strict and (self_task == target_task)) or \
-                (not strict and (self_task >= target_task)):
-                return func(*args, **kwargs)
-            else:
-                raise RuntimeError('This method is not available for {} tasks'.format(self_task.name.lower()))
+            self = args[0]
+            # Check rediness
+            if ready and not self.is_ready():
+                raise RuntimeError('Model is not ready yet.')
+            # Check explainable
+            if explainable and not self._is_explainable:
+                model_name = type(self._model).__name__
+                raise ValueError('Model not supported for explanations: {}'.format(model_name))
+            # Check for task
+            if task is not None:
+                self_task = self.task_type()
+                if not getattr(self_task, '__ge__' if task.upper() == 'CLASSIFICATION' else '__eq__')(Task(task)):
+                    raise RuntimeError('This method is not available for {} tasks'.format(self_task.name.lower()))
+            # Execute function
+            return func(*args, **kwargs)
         return wrapper
     return actual_decorator
 
@@ -67,6 +63,7 @@ def __repr__(self):
 
 class BaseModel(object):
     """Base Class that handles the loaded model."""
+    family = ''
     # Explainable models
     _explainable_models = tuple()
 
@@ -76,34 +73,33 @@ def __init__(self, file_name):
         self._model = None
         self._metadata = None
         self._task_type = None
+        self._is_explainable = False
 
     # Abstract
     def _load(self):
         raise NotImplementedError()
 
-    @_check_readiness
+    @_check()
     def _get_predictor(self):
         raise NotImplementedError()
 
-    @_check_readiness
-    @_check_task('classification')
+    @_check(task='classification')
     def _get_class_names(self):
         raise NotImplementedError()
 
-    @_check_readiness
-    def preprocess(self, input):
+    @_check()
+    def preprocess(self, features):
         raise NotImplementedError()
 
-    @_check_readiness
+    @_check()
     def predict(self, features):
         raise NotImplementedError()
 
-    @_check_readiness
-    @_check_task('classification')
+    @_check(task='classification')
     def predict_proba(self, features):
         raise NotImplementedError()
 
-    @_check_readiness
+    @_check(explainable=True)
     def explain(self, features, samples=None):
         raise NotImplementedError()
 
@@ -131,11 +127,11 @@ def _hydrate(self, model, metadata):
         elif len(clf.classes_) > 2:
             self._task_type = Task('MULTILABEL_CLASSIFICATION')
 
-    @_check_readiness
+    @_check()
     def _feature_names(self):
         return [variable['name'] for variable in self.features()]
 
-    @_check_readiness
+    @_check()
     def _validate(self, input):
         if self.metadata.get('features') is None:
             raise AttributeError("Missing key 'features' in model's metadata")
@@ -175,22 +171,22 @@ def _validate(self, input):
         return df
 
     @property
-    @_check_readiness
+    @_check()
     def _is_classification(self):
         return self._task_type >= Task('CLASSIFICATION')
 
     @property
-    @_check_readiness
+    @_check()
     def _is_binary_classification(self):
         return self._task_type == Task('BINARY_CLASSIFICATION')
 
     @property
-    @_check_readiness
+    @_check()
     def _is_multilabel_classification(self):
         return self._task_type == Task('MULTILABEL_CLASSIFICATION')
 
     @property
-    @_check_readiness
+    @_check()
     def _is_regression(self):
         return self._task_type == Task('REGRESSION')
 
@@ -229,7 +225,7 @@ def is_ready(self):
         return self._is_ready
 
     @property
-    @_check_readiness
+    @_check()
     def metadata(self):
         """Get metadata of the model_name.
 
@@ -243,7 +239,7 @@ def metadata(self):
         """
         return self._metadata
 
-    @_check_readiness
+    @_check()
     def task_type(self, as_text=False):
         """Get task type of the model
 
@@ -262,7 +258,7 @@ def task_type(self, as_text=False):
         """
         return self._task_type.name if as_text else self._task_type
 
-    @_check_readiness
+    @_check()
     def features(self):
         """Get the features of the model
 
@@ -281,7 +277,7 @@ def features(self):
         return deepcopy(self.metadata['features'])
 
     @property
-    @_check_readiness
+    @_check()
     def info(self):
         """Get model information.
 
@@ -321,7 +317,8 @@ def info(self):
             'type': str(type(self._model)),
             'predictor_type': str(type(self._get_predictor())),
             'is_explainable': self._is_explainable,
-            'task': self.task_type(as_text=True)
+            'task': self.task_type(as_text=True),
+            'family': self.family
         }
         if self._is_classification:
             result['model']['class_names'] = self._get_class_names()

python/model/sklearn.py

@@ -2,7 +2,7 @@
 import numpy as np
 import pandas as pd
 
-from .base import  BaseModel, Task, _check_task, _check_readiness
+from .base import  BaseModel, Task, _check
 
 try:
     import shap
@@ -27,6 +27,8 @@ class SklearnModel(BaseModel):
             File path of the serialized model. It must be a file that can be
             loaded using :mod:`joblib`
     """
+    family = 'SKLEARN_MODEL'
+
     # Explainable models
     _explainable_models = (
         # Sklearn
@@ -45,12 +47,11 @@ def _load(self):
         loaded = joblib.load(self._file_name)
         self._hydrate(loaded['model'], loaded['metadata'])
 
-    @_check_readiness
+    @_check()
     def _get_predictor(self):
         return SklearnModel._extract_base_predictor(self._model)
 
-    @_check_readiness
-    @_check_task('classification')
+    @_check(task='classification')
     def _get_class_names(self):
         return np.array(self._get_predictor().classes_, str)
 
@@ -65,14 +66,15 @@ def _extract_base_predictor(model):
         else:
             return model
 
-    @_check_readiness
-    def preprocess(self, input):
+    # Public
+    @_check()
+    def preprocess(self, features):
         """Preprocess data
 
         This function is used before prediction or interpretation.
 
         Args:
-            input (dict):
+            features (dict):
                 The expected object must contain one key per feature.
                 Example: `{'feature1': 5, 'feature2': 'A', 'feature3': 10}`
 
@@ -84,12 +86,13 @@ def preprocess(self, input):
         Raises:
             RuntimeError: If the model is not ready.
         """
+        input = self._validate(features)
         if hasattr(self._model, 'transform'):
             return self._model.transform(input)
         else:
             return input
 
-    @_check_readiness
+    @_check()
     def predict(self, features):
         """Make a prediciton
 
@@ -114,8 +117,7 @@ def predict(self, features):
         result = self._model.predict(input)
         return result
 
-    @_check_readiness
-    @_check_task('classification')
+    @_check(task='classification')
     def predict_proba(self, features):
         """Make a prediciton
 
@@ -140,7 +142,7 @@ def predict_proba(self, features):
         df = pd.DataFrame(prediction, columns=self._get_class_names())
         return df.to_dict(orient='records')
 
-    @_check_readiness
+    @_check(explainable=True)
     def explain(self, features, samples=None):
         """Explain the prediction of a model.
 
@@ -173,13 +175,8 @@ def explain(self, features, samples=None):
                 explanations or the model is not already loaded.
                 Or if the explainer outputs an unknown object
         """
-        if not self._is_explainable:
-            model_name = type(self._model).__name__
-            msg = 'Model not supported for explanations: {}'.format(model_name)
-            raise ValueError(msg)
         # Process input
-        input = self._validate(features)
-        preprocessed = self.preprocess(input)
+        preprocessed = self.preprocess(features)
         # Define parameters
         if samples is None:
             params = {

python/utils/encoder.py

@@ -1,19 +1,24 @@
 import flask
 import json
 import numpy as np
+import pandas as pd
 
 from functools import wraps
 
 
-class NumpyEncoder(flask.json.JSONEncoder):
-    """Encoder of numpy primitives into JSON strings"""
+class ExtendedEncoder(flask.json.JSONEncoder):
+    """Encoder of numpy primitives and Pandas objects into JSON strings"""
     primitives = (np.ndarray, np.integer, np.inexact)
 
     def default(self, obj):
         if isinstance(obj, np.flexible):
             return None if isinstance(obj, np.void) else obj.tolist()
         elif isinstance(obj, self.primitives):
             return obj.tolist()
+        elif isinstance(obj, pd.DataFrame):
+            return obj.to_dict('records')
+        elif isinstance(obj, pd.Series):
+            return json.JSONEncoder.default(self, obj.to_frame())
         return json.JSONEncoder.default(self, obj)
 
 
@@ -26,6 +31,6 @@ def decorated_function(*args, **kwargs):
         if isinstance(r, flask.Response):
             return r
         else:
-            return flask.Response(json.dumps(r, cls=NumpyEncoder), status=200,
+            return flask.Response(json.dumps(r, cls=ExtendedEncoder), status=200,
                                   mimetype='application/json; charset=utf-8')
     return decorated_function

service.py

@@ -11,7 +11,7 @@
 
 from time import time
 
-from python.utils.encoder import NumpyEncoder, returns_json
+from python.utils.encoder import ExtendedEncoder, returns_json
 from python.factory import ModelFactory
 
 # Version of this APP template
@@ -26,7 +26,7 @@
 app = flask.Flask(__name__)
 # Customize Flask Application
 app.logger.setLevel(logging.DEBUG if DEBUG else logging.ERROR)
-app.json_encoder = NumpyEncoder
+app.json_encoder = ExtendedEncoder
 # Create Model instance
 model = ModelFactory.create_model(MODEL_NAME, MODEL_TYPE)
 # laod saved model
@@ -183,7 +183,7 @@ def service_info():
         'version-template': __version__,
         'running-since': SERVICE_START_TIMESTAMP,
         'serving-model-file': MODEL_NAME,
-        'serving-model-type': MODEL_TYPE,
+        'serving-model-family': model.family,
         'debug': DEBUG}
     return info