minor refactorings in naming conventions (#116)

Author: AHReccese

pymilo/chains/ensemble_chain.py

@@ -188,19 +188,16 @@ def serialize_ensemble(ensemble_object):
                 }
 
         elif isinstance(value, dict):
-            if not check_str_in_iterable("pymilo-bypass", value):
-                if check_str_in_iterable(
-                    "pymiloed-data-structure",
-                        value) and value["pymiloed-data-structure"] == "Bunch":
-                    new_value = {}
-                    for inner_key, inner_value in value["pymiloed-data"].items():
-                        new_value[inner_key] = serialize_possible_ml_model(inner_value)[1]
-                    value["pymiloed-data"] = new_value
-                else:
-                    new_value = {}
-                    for inner_key, inner_value in value.items():
-                        new_value[inner_key] = serialize_possible_ml_model(inner_value)[1]
-                    ensemble_object.__dict__[key] = new_value
+            if check_str_in_iterable("pymilo-bunch", value):
+                new_value = {}
+                for inner_key, inner_value in value["pymilo-bunch"].items():
+                    new_value[inner_key] = serialize_possible_ml_model(inner_value)[1]
+                value["pymilo-bunch"] = new_value
+            else:
+                new_value = {}
+                for inner_key, inner_value in value.items():
+                    new_value[inner_key] = serialize_possible_ml_model(inner_value)[1]
+                ensemble_object.__dict__[key] = new_value
 
         elif isinstance(value, ndarray):
             has_inner_model, result = serialize_models_in_ndarray(value)

pymilo/chains/linear_model_chain.py

@@ -104,7 +104,7 @@ def serialize_linear_model(linear_model_object):
             linear_model_object.__dict__[key] = {
                 "pymilo-inner-model-data": transport_linear_model(linear_model_object.__dict__[key], Command.SERIALIZE, True),
                 "pymilo-inner-model-type": get_sklearn_type(linear_model_object.__dict__[key]),
-                "pymilo-by-pass": True
+                "pymilo-bypass": True
             }
     # now serializing non-linear model fields
     for transporter in LINEAR_MODEL_CHAIN:

pymilo/transporters/adamoptimizer_transporter.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 """PyMilo Adam optimizer object transporter."""
-from sklearn.neural_network._stochastic_optimizers import AdamOptimizer
 from .transporter import AbstractTransporter
+from ..utils.util import check_str_in_iterable
+from sklearn.neural_network._stochastic_optimizers import AdamOptimizer
 
 
 class AdamOptimizerTransporter(AbstractTransporter):
@@ -24,7 +25,8 @@ def serialize(self, data, key, model_type):
         if isinstance(data[key], AdamOptimizer):
             optimizer = data[key]
             data[key] = {
-                'params': {
+                "pymilo-bypass": True,
+                'pymilo-adamoptimizer': {
                     "params": data["coefs_"] + data["intercepts_"],
                     'type': "AdamOptimizer",
                     'beta_1': optimizer.beta_1,
@@ -55,10 +57,8 @@ def deserialize(self, data, key, model_type):
         :return: pymilo deserialized output of data[key]
         """
         content = data[key]
-
-        if (key == "_optimizer" and (model_type ==
-                                     "MLPRegressor" or model_type == "MLPClassifier")):
-            optimizer = content['params']
+        if check_str_in_iterable("pymilo-adamoptimizer", content):
+            optimizer = content["pymilo-adamoptimizer"]
             if (optimizer["type"] == "AdamOptimizer"):
                 return AdamOptimizer(
                     params=optimizer["params"],

pymilo/transporters/bunch_transporter.py

@@ -1,8 +1,8 @@
 # -*- coding: utf-8 -*-
 """PyMilo Bunch transporter."""
-
-from ..utils.util import check_str_in_iterable
 from .transporter import AbstractTransporter
+from ..utils.util import check_str_in_iterable
+
 bunch_support = False
 try:
     from sklearn.utils._bunch import Bunch
@@ -28,13 +28,13 @@ def serialize(self, data, key, model_type):
         """
         if bunch_support and isinstance(data[key], Bunch):
             bunch = data[key]
-            dicted_bunch = {}
-            dicted_bunch["pymiloed-data-structure"] = "Bunch"
             _dict = {}
             for key, value in bunch.items():
                 _dict[key] = value
-            dicted_bunch["pymiloed-data"] = _dict
-            return dicted_bunch
+            return {
+                "pymilo-bypass": True,
+                "pymilo-bunch": _dict,
+            }
 
         return data[key]
 
@@ -56,12 +56,9 @@ def deserialize(self, data, key, model_type):
         :return: pymilo deserialized output of data[key]
         """
         content = data[key]
-        if bunch_support and check_str_in_iterable(
-            "pymiloed-data-structure",
-                content) and content["pymiloed-data-structure"] == "Bunch":
+        if bunch_support and check_str_in_iterable("pymilo-bunch", content):
             bunch = Bunch()
-            dicted_bunch = content["pymiloed-data"]
-            for key, value in dicted_bunch.items():
+            for key, value in content["pymilo-bunch"].items():
                 bunch[key] = value
             return bunch
         else:

pymilo/transporters/randomstate_transporter.py

@@ -2,7 +2,7 @@
 """PyMilo RandomState(MT19937) object transporter."""
 import numpy as np
 from .transporter import AbstractTransporter
-
+from ..utils.util import check_str_in_iterable
 
 class RandomStateTransporter(AbstractTransporter):
     """Customized PyMilo Transporter developed to handle RandomState field."""
@@ -24,14 +24,15 @@ def serialize(self, data, key, model_type):
         if isinstance(data[key], np.random.RandomState):
             inner_random_state = data[key]
             data[key] = {
-                'state': (
+                "pymilo-bypass": True,
+                "pymilo-randomstate": (
                     inner_random_state.get_state()[0],
                     inner_random_state.get_state()[1].tolist(),
                     inner_random_state.get_state()[2],
                     inner_random_state.get_state()[3],
-                    inner_random_state.get_state()[4]
-                )
-            }
+                    inner_random_state.get_state()[4],
+                    ),
+                }
         return data[key]
 
     def deserialize(self, data, key, model_type):
@@ -56,15 +57,14 @@ def deserialize(self, data, key, model_type):
         """
         content = data[key]
 
-        if key == "_random_state" and (
-                model_type == "MLPRegressor" or model_type == "MLPClassifier"):
-            inner_random_state = content['state']
+        if check_str_in_iterable("pymilo-randomstate", content):
+            inner_random_state = content["pymilo-randomstate"]
             inner_random_state = (
                 inner_random_state[0],
                 np.array(inner_random_state[1]),
                 inner_random_state[2],
                 inner_random_state[3],
-                inner_random_state[4]
+                inner_random_state[4],
             )
             _random_state = np.random.RandomState()
             _random_state.set_state(inner_random_state)

pymilo/transporters/sgdoptimizer_transporter.py

@@ -1,7 +1,8 @@
 # -*- coding: utf-8 -*-
 """PyMilo SGDOptimizer object transporter."""
-from sklearn.neural_network._stochastic_optimizers import SGDOptimizer
 from .transporter import AbstractTransporter
+from ..utils.util import check_str_in_iterable
+from sklearn.neural_network._stochastic_optimizers import SGDOptimizer
 
 
 class SGDOptimizerTransporter(AbstractTransporter):
@@ -24,7 +25,8 @@ def serialize(self, data, key, model_type):
         if isinstance(data[key], SGDOptimizer):
             optimizer = data[key]
             data[key] = {
-                'params': {
+                "pymilo-bypass": True,
+                'pymilo-sgdoptimizer': {
                     'type': "SGDOptimizer",
                     'learning_rate': optimizer.learning_rate,
                     'momentum': optimizer.momentum,
@@ -55,10 +57,8 @@ def deserialize(self, data, key, model_type):
         :return: pymilo deserialized output of data[key]
         """
         content = data[key]
-
-        if (key == "_optimizer" and (model_type ==
-                                     "MLPRegressor" or model_type == "MLPClassifier")):
-            optimizer = content['params']
+        if check_str_in_iterable('pymilo-sgdoptimizer', content):
+            optimizer = content['pymilo-sgdoptimizer']
             if (optimizer["type"] == "SGDOptimizer"):
                 return SGDOptimizer(
                     learning_rate=optimizer['learning_rate'],

pymilo/transporters/tree_transporter.py

@@ -1,12 +1,11 @@
 # -*- coding: utf-8 -*-
 """PyMilo Tree(from sklearn.tree._tree) object transporter."""
+import numpy as np
 from sklearn.tree._tree import Tree
-
+from ..pymilo_param import NUMPY_TYPE_DICT
 from .transporter import AbstractTransporter
+from ..utils.util import check_str_in_iterable
 from .general_data_structure_transporter import GeneralDataStructureTransporter
-from ..pymilo_param import NUMPY_TYPE_DICT
-
-import numpy as np
 
 
 class TreeTransporter(AbstractTransporter):
@@ -28,10 +27,9 @@ def serialize(self, data, key, model_type):
             gdst = GeneralDataStructureTransporter()
             tree = data[key]
             tree_inner_state = tree.__getstate__()
-
             data[key] = {
                 'pymilo-bypass': True,
-                'params': {
+                'pymilo-tree': {
                     'internal_state': {
                         "max_depth": tree_inner_state["max_depth"],
                         "node_count": tree_inner_state["node_count"],
@@ -47,7 +45,6 @@ def serialize(self, data, key, model_type):
                     'n_outputs': tree.n_outputs,
                 }
             }
-
         return data[key]
 
     def deserialize(self, data, key, model_type):
@@ -69,19 +66,12 @@ def deserialize(self, data, key, model_type):
         :return: pymilo deserialized output of data[key]
         """
         content = data[key]
-
-        if (key == "tree_" and
-            (model_type == "DecisionTreeRegressor"
-             or model_type == "DecisionTreeClassifier"
-             or model_type == "ExtraTreeRegressor"
-             or model_type == "ExtraTreeClassifier"
-             )):
+        if check_str_in_iterable('pymilo-tree', content):
             gdst = GeneralDataStructureTransporter()
-            tree_params = content['params']
-
+            tree_params = content['pymilo-tree']
             tree_internal_state = tree_params["internal_state"]
-
             nodes_dtype_spec = []
+
             for idx, node_type in enumerate(tree_internal_state["nodes"]["types"]):
                 nodes_dtype_spec.append(
                     (tree_internal_state["nodes"]["field-names"][idx], NUMPY_TYPE_DICT["numpy." + node_type]))
@@ -106,10 +96,7 @@ def deserialize(self, data, key, model_type):
                 n_classes,
                 tree_params["n_outputs"]
             )
-
             _tree.__setstate__(tree_internal_state)
-
             return _tree
-
         else:
             return content