DecisionTreeRegressor

.gitignore

@@ -101,4 +101,5 @@ gen
 
 /tests/exported_linear_models 
 /tests/exported_neural_networks
+/tests/exported_decision_trees
 /.VSCodeCounter

CHANGELOG.md

@@ -5,8 +5,15 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+### Added
+- scikit-learn decision tree models
+- `DecisionTreeRegressor` model
+- `Tree` Transporter
+- Decision Tree chain
 ### Changed
 - Tests config modified
+- DecisionTree params initialized in `pymilo_param`
+- Decision Tree support added to `pymilo_func.py`
 ## [0.2] - 2023-08-02
 ### Added
 - scikit-learn neural network models 

pymilo/chains/decision_tree_chain.py

@@ -0,0 +1,136 @@
+# -*- coding: utf-8 -*-
+"""PyMilo chain for decision trees."""
+from ..transporters.transporter import Command
+
+from ..transporters.general_data_structure_transporter import GeneralDataStructureTransporter
+from ..transporters.tree_transporter import TreeTransporter
+
+from ..pymilo_param import SKLEARN_DECISION_TREE_TABLE
+
+from ..exceptions.serialize_exception import PymiloSerializationException, SerilaizatoinErrorTypes
+from ..exceptions.deserialize_exception import PymiloDeserializationException, DeSerilaizatoinErrorTypes
+from traceback import format_exc
+
+
+DECISION_TREE_CHAIN = {
+    "GeneralDataStructureTransporter": GeneralDataStructureTransporter(),
+    "TreeTransporter": TreeTransporter(),
+}
+
+
+def is_decision_tree(model):
+    """
+    Check if the input model is a sklearn's decision tree.
+
+    :param model: is a string name of a decision tree or a sklearn object of it
+    :type model: any object
+    :return: check result as bool
+    """
+    if isinstance(model, str):
+        return model in SKLEARN_DECISION_TREE_TABLE.keys()
+    else:
+        return type(model) in SKLEARN_DECISION_TREE_TABLE.values()
+
+
+def transport_decision_tree(request, command):
+    """
+    Return the transported (Serialized or Deserialized) model.
+
+    :param request: given decision tree model to be transported
+    :type request: any object
+    :param command: command to specify whether the request should be serialized or deserialized
+    :type command: transporter.Command
+    :return: the transported request as a json string or sklearn decision tree model
+    """
+    _validate_input(request, command)
+
+    if command == Command.SERIALIZE:
+        try:
+            return serialize_decision_tree(request)
+        except Exception as e:
+            raise PymiloSerializationException(
+                {
+                    'error_type': SerilaizatoinErrorTypes.VALID_MODEL_INVALID_INTERNAL_STRUCTURE,
+                    'error': {
+                        'Exception': repr(e),
+                        'Traceback': format_exc(),
+                    },
+                    'object': request,
+                })
+
+    elif command == Command.DESERIALZIE:
+        try:
+            return deserialize_decision_tree(request)
+        except Exception as e:
+            raise PymiloDeserializationException(
+                {
+                    'error_type': SerilaizatoinErrorTypes.VALID_MODEL_INVALID_INTERNAL_STRUCTURE,
+                    'error': {
+                        'Exception': repr(e),
+                        'Traceback': format_exc()},
+                    'object': request})
+
+
+def serialize_decision_tree(decision_tree_object):
+    """
+    Return the serialized json string of the given decision tree model.
+
+    :param decision_tree_object: given model to be get serialized
+    :type decision_tree_object: any sklearn decision tree model
+    :return: the serialized json string of the given decision tree model
+    """
+    for transporter in DECISION_TREE_CHAIN.keys():
+        DECISION_TREE_CHAIN[transporter].transport(
+            decision_tree_object, Command.SERIALIZE)
+    return decision_tree_object.__dict__
+
+
+def deserialize_decision_tree(decision_tree):
+    """
+    Return the associated sklearn decision tree model of the given decision_tree.
+
+    :param decision_tree: given json string of a decision tree model to get deserialized to associated sklearn decision tree model
+    :type decision_tree: obj
+    :return: associated sklearn decision tree model
+    """
+    raw_model = SKLEARN_DECISION_TREE_TABLE[decision_tree.type]()
+    data = decision_tree.data
+
+    for transporter in DECISION_TREE_CHAIN.keys():
+        DECISION_TREE_CHAIN[transporter].transport(
+            decision_tree, Command.DESERIALZIE)
+    for item in data.keys():
+        setattr(raw_model, item, data[item])
+    return raw_model
+
+
+def _validate_input(model, command):
+    """
+    Check if the provided inputs are valid in relation to each other.
+
+    :param model: a sklearn decision tree model or a json string of it, serialized through the pymilo export.
+    :type model: obj
+    :param command: command to specify whether the request should be serialized or deserialized
+    :type command: transporter.Command
+    :return: None
+    """
+    if command == Command.SERIALIZE:
+        if is_decision_tree(model):
+            return
+        else:
+            raise PymiloSerializationException(
+                {
+                    'error_type': SerilaizatoinErrorTypes.INVALID_MODEL,
+                    'object': model
+                }
+            )
+    elif command == Command.DESERIALZIE:
+        if is_decision_tree(model.type):
+            return
+        else:
+            raise PymiloDeserializationException(
+                {
+                    'error_type': DeSerilaizatoinErrorTypes.INVALID_MODEL,
+                    'object': model
+                }
+            )

pymilo/chains/linear_model_chain.py

@@ -151,8 +151,7 @@ def validate_input(model, command, is_inner_model):
     """
     Check if the provided inputs are valid in relation to each other.
 
-    :param model: given object to gets transported, whether a sklearn linear model to get serialized
-    or a json string of a linear model to get deserialized to associated sklearn linear model
+    :param model: a sklearn linear model or a json string of it, serialized through the pymilo export.
     :type model: obj
     :param command: command to specify whether the request should be serialized or deserialized
     :type command: transporter.Command

pymilo/chains/neural_network_chain.py

@@ -114,8 +114,7 @@ def _validate_input(model, command):
     """
     Check if the provided inputs are valid in relation to each other.
 
-    :param model: given object to gets transported, whether a sklearn neural network model to get serialized
-    or a json string of a neural network model to get deserialized to associated sklearn neural network model
+    :param model: a sklearn neural network model or a json string of it, serialized through the pymilo export.
     :type model: obj
     :param command: command to specify whether the request should be serialized or deserialized
     :type command: transporter.Command

pymilo/pymilo_func.py

@@ -5,6 +5,7 @@
 
 from .chains.linear_model_chain import transport_linear_model, is_linear_model
 from .chains.neural_network_chain import transport_neural_network, is_neural_network
+from .chains.decision_tree_chain import transport_decision_tree, is_decision_tree
 
 from .transporters.transporter import Command
 
@@ -30,6 +31,8 @@ def get_sklearn_data(model):
         return transport_linear_model(model, Command.SERIALIZE)
     elif is_neural_network(model):
         return transport_neural_network(model, Command.SERIALIZE)
+    elif is_decision_tree(model):
+        return transport_decision_tree(model, Command.SERIALIZE)
     else:
         return None
 
@@ -46,6 +49,8 @@ def to_sklearn_model(import_obj):
         return transport_linear_model(import_obj, Command.DESERIALZIE)
     elif is_neural_network(import_obj.type):
         return transport_neural_network(import_obj, Command.DESERIALZIE)
+    elif is_decision_tree(import_obj.type):
+        return transport_decision_tree(import_obj, Command.DESERIALZIE)
     else:
         return None
 

pymilo/pymilo_param.py

@@ -35,10 +35,15 @@
 from sklearn.neural_network import MLPClassifier
 from sklearn.neural_network import BernoulliRBM
 
+from sklearn.tree import DecisionTreeRegressor
+
 from numpy import int64
 from numpy import int32
+from numpy import float64
+from numpy import inf
+from numpy import uint8
+
 from sklearn.preprocessing import LabelBinarizer
-import numpy as np
 
 PYMILO_VERSION = "0.2"
 NOT_SUPPORTED = "NOT_SUPPORTED"
@@ -119,6 +124,11 @@
     "MLPClassifier": MLPClassifier,
     "BernoulliRBM": BernoulliRBM,
 }
+
+SKLEARN_DECISION_TREE_TABLE = {
+    "DecisionTreeRegressor": DecisionTreeRegressor
+}
+
 KEYS_NEED_PREPROCESSING_BEFORE_DESERIALIZATION = {
     "_label_binarizer": LabelBinarizer,  # in Ridge Classifier
     "active_": int32,  # in Lasso Lars
@@ -132,10 +142,13 @@
 NUMPY_TYPE_DICT = {
     "numpy.int32": int32,
     "numpy.int64": int64,
-    "numpy.infinity": lambda _: np.inf
+    "numpy.float64": float64,
+    "numpy.infinity": lambda _: inf,
+    "numpy.uint8": uint8,
 }
 
 EXPORTED_MODELS_PATH = {
     "LINEAR_MODEL": "exported_linear_models",
-    "NEURAL_NETWORK": "exported_neural_networks"
+    "NEURAL_NETWORK": "exported_neural_networks",
+    "DECISION_TREE": "exported_decision_trees"
 }

pymilo/transporters/tree_transporter.py

@@ -0,0 +1,108 @@
+# -*- coding: utf-8 -*-
+"""PyMilo Tree(from sklearn.tree._tree) object transporter."""
+from sklearn.tree._tree import Tree
+
+from .transporter import AbstractTransporter
+from .general_data_structure_transporter import GeneralDataStructureTransporter
+from ..pymilo_param import NUMPY_TYPE_DICT
+
+import numpy as np
+
+class TreeTransporter(AbstractTransporter):
+    """Customized PyMilo Transporter developed to handle (pyi,pyx) Tree object."""
+
+    def serialize(self, data, key, model_type):
+        """
+        Serialize instances of the Tree class by recording the n_features, n_classes and n_outputs fields of tree object.
+
+        :param data: the internal data dictionary of the given model
+        :type data: dict
+        :param key: the special key of the data param, which we're going to serialize its value(data[key])
+        :type key: object
+        :param model_type: the model type of the ML model
+        :type model_type: str
+        :return: pymilo serialized output of data[key]
+        """
+        if isinstance(data[key], Tree):
+            gdst = GeneralDataStructureTransporter()
+            tree = data[key]
+            tree_inner_state = tree.__getstate__()
+
+            data[key] = {
+                'params': {
+                    'internal_state': {
+                        "max_depth": tree_inner_state["max_depth"],
+                        "node_count": tree_inner_state["node_count"],
+                        "nodes": {
+                            "types": [str(np.dtype(i).name) for i in tree_inner_state["nodes"][0]],
+                            "field-names": list(tree_inner_state["nodes"][0].dtype.names),
+                            "values": [node.tolist() for node in tree_inner_state["nodes"]],
+                        },
+                        "values": gdst.ndarray_to_list(tree_inner_state["values"]),
+                    },
+                    'n_features': tree.n_features,
+                    'n_classes': gdst.ndarray_to_list(tree.n_classes),
+                    'n_outputs': tree.n_outputs,
+                }
+            }
+
+        return data[key]
+
+    def deserialize(self, data, key, model_type):
+        """
+        Deserialize the special tree_ field of the Decision Trees.
+
+        The associated tree_ field of the pymilo serialized model, is extracted through
+        it's previously serialized parameters.
+        deserialize the data[key] of the given model which type is model_type.
+        basically in order to fully deserialize a model, we should traverse over all the keys of its serialized data dictionary and
+        pass it through the chain of associated transporters to get fully deserialized.
+
+        :param data: the internal data dictionary of the associated JSON file of the ML model generated by pymilo export.
+        :type data: dict
+        :param key: the special key of the data param, which we're going to deserialize its value(data[key])
+        :type key: object
+        :param model_type: the model type of the ML model
+        :type model_type: str
+        :return: pymilo deserialized output of data[key]
+        """
+        content = data[key]
+
+        if (key == "tree_" and (model_type == "DecisionTreeRegressor")):
+            gdst = GeneralDataStructureTransporter()
+            tree_params = content['params']
+
+            tree_internal_state = tree_params["internal_state"]
+
+            nodes_dtype_spec = []
+            for i in range(len(tree_internal_state["nodes"]["types"])):
+                nodes_dtype_spec.append(
+                    (tree_internal_state["nodes"]["field-names"][i], NUMPY_TYPE_DICT["numpy." + tree_internal_state["nodes"]["types"][i]]))
+            nodes = [tuple(node)
+                     for node in tree_internal_state["nodes"]["values"]]
+            nodes = np.array(nodes, dtype=nodes_dtype_spec)
+
+            tree_internal_state = {
+                "max_depth": tree_internal_state["max_depth"],
+                "node_count": tree_internal_state["node_count"],
+                "nodes": nodes,
+                "values": gdst.list_to_ndarray(tree_internal_state["values"]),
+            }
+
+            n_classes = np.ndarray(
+                shape=(np.intp(len(tree_params["n_classes"])),), dtype=np.intp)
+            for i in range(len(n_classes)):
+                n_classes[i] = tree_params["n_classes"][i]
+
+            _tree = Tree(
+                tree_params["n_features"],
+                n_classes,
+                tree_params["n_outputs"]
+            )
+
+            _tree.__setstate__(tree_internal_state)
+
+            return _tree
+
+        else:
+            return content

pymilo/utils/test_pymilo.py

@@ -12,6 +12,7 @@
 
 from ..chains.linear_model_chain import is_linear_model
 from ..chains.neural_network_chain import is_neural_network
+from ..chains.decision_tree_chain import is_decision_tree
 
 from ..pymilo_param import EXPORTED_MODELS_PATH
 
@@ -29,6 +30,8 @@
         model_type = "LINEAR_MODEL"
     elif is_neural_network(model):
         model_type = "NEURAL_NETWORK"
+    elif is_decision_tree(model):
+        model_type = "DECISION_TREE"
     else:
         model_type = None
     return EXPORTED_MODELS_PATH[model_type]
@@ -130,6 +133,6 @@
     :return: None
     """
     if result:
-        print('Pymilo Test for Model:' + model_name + ' succeed.')
+        print('Pymilo Test for Model: ' + model_name + ' succeed.')
     else:
-        print('Pymilo Test for Model:' + model_name + ' failed.')
+        print('Pymilo Test for Model: ' + model_name + ' failed.')