obliquetree 1.0.1__cp313-cp313-win_amd64.whl → 1.0.3__cp313-cp313-win_amd64.whl

obliquetree/utils.py

@@ -6,6 +6,7 @@ import json
 from typing import Optional, Dict, Any, List, Union
 from io import BytesIO
 import os
+import numpy as np
 
 
 def load_tree(tree_data: Union[str, Dict]) -> Union[Classifier, Regressor]:
@@ -329,6 +330,361 @@ def visualize_tree(
         savefig(save_path, dpi=dpi, bbox_inches="tight", pad_inches=0)
 
     show()
+    
+def export_tree_to_onnx(tree: Union[Classifier, Regressor]) -> None:
+    """
+    Convert an oblique decision tree (Classifier or Regressor) into an ONNX model.
+
+    .. important::
+       - This implementation currently does **not** support batch processing.
+         Only a single row (1D NumPy array) and np.float64 dtype can be passed as input.
+       - The input variable name must be **"X"** and its shape should be (n_features,).
+       - In binary classification, the output is a single-dimensional value representing 
+         the probability of belonging to the positive class.
+
+    Parameters
+    ----------
+    tree : Union[Classifier, Regressor]
+        The oblique decision tree (classifier or regressor) to be converted to ONNX.
+
+    Returns
+    -------
+    onnx.ModelProto
+        The constructed ONNX model.
+
+    Examples
+    --------
+    >>> # Suppose we have a 2D NumPy array X of shape (num_samples, num_features).
+    >>> # We only take a single row for prediction:
+    >>> X_sample = X[0, :]
+    >>> 
+    >>> # Create an inference session using onnxruntime:
+    >>> import onnxruntime
+    >>> session = onnxruntime.InferenceSession("tree.onnx")
+    >>> 
+    >>> # Retrieve the output name of the model
+    >>> out_name = session.get_outputs()[0].name
+    >>> 
+    >>> # Perform inference on the sample
+    >>> y_pred = session.run([out_name], {"X": X_sample})[0]
+    >>> print(y_pred)
+    """
+    try:
+        from onnx import helper, TensorProto
+    except ImportError as e:
+        raise ImportError(
+            "Failed to import onnx dependencies. Please make sure the 'onnx' "
+            "package is installed."
+        ) from e
+    
+    tree_dict = export_tree(tree)
+
+    # Closure for unique name generation
+    name_counter = [0]
+
+    def _unique_name(prefix="Node"):
+        name_counter[0] += 1
+        return f"{prefix}_{name_counter[0]}"
+
+    def _make_constant_int_node(name, value, shape=None):
+        """
+        Creates an ONNX Constant node containing int64 data.
+        Useful for indices in Gather or other integer-only parameters.
+        """
+        if shape is None:
+            shape = [len(value)] if isinstance(value, list) else []
+        arr = (
+            np.array(value, dtype=np.int64)
+            if isinstance(value, list)
+            else (
+                np.array([value], dtype=np.int64)
+                if shape == []
+                else np.array(value, dtype=np.int64)
+            )
+        )
+
+        const_tensor = helper.make_tensor(
+            name=_unique_name("const_data_int"),
+            data_type=TensorProto.INT64,
+            dims=arr.shape,
+            vals=arr.flatten().tolist(),
+        )
+
+        node = helper.make_node(
+            "Constant", inputs=[], outputs=[name], value=const_tensor
+        )
+        return node
+
+    def _make_constant_float_node(name, value, shape=None):
+        """
+        Creates an ONNX Constant node containing float64 data.
+        Useful for thresholds, weights, etc.
+        """
+        if shape is None:
+            shape = [len(value)] if isinstance(value, list) else []
+        arr = (
+            np.array(value, dtype=np.float64)
+            if isinstance(value, list)
+            else np.array([value], dtype=np.float64)
+        )
+
+        if shape and arr.shape != tuple(shape):
+            arr = arr.reshape(shape)
+
+        const_tensor = helper.make_tensor(
+            name=_unique_name("const_data_float"),
+            data_type=TensorProto.DOUBLE,
+            dims=arr.shape,
+            vals=arr.flatten().tolist(),
+        )
+        node = helper.make_node(
+            "Constant", inputs=[], outputs=[name], value=const_tensor
+        )
+        return node
+
+    def _build_subgraph_for_node(node_dict, n_classes):
+        """
+        Recursively builds a subgraph (for 'If' branches) from the given node definition.
+        The subgraph uses 'X' as an outer-scope input (not declared in inputs[]).
+        """
+        nodes = []
+        graph_name = _unique_name("SubGraph")
+
+        # Subgraph output
+        out_name = _unique_name("sub_out")
+        out_info = helper.make_tensor_value_info(out_name, TensorProto.DOUBLE, None)
+
+        # Reference to 'X' from the outer scope
+        x_info = helper.make_tensor_value_info("X", TensorProto.DOUBLE, [None])
+
+        # If this is a leaf node
+        if node_dict["is_leaf"]:
+            if "values" in node_dict and isinstance(node_dict["values"], list):
+                # Multi-class leaf
+                val_array = node_dict["values"]
+                shape = [len(val_array)]
+                cnode = _make_constant_float_node(out_name, val_array, shape)
+                nodes.append(cnode)
+            else:
+                # Single-value leaf (binary or regression)
+                val = node_dict["value"]
+                cnode = _make_constant_float_node(out_name, val, [])
+                nodes.append(cnode)
+
+            subgraph = helper.make_graph(
+                nodes=nodes,
+                name=graph_name,
+                inputs=[],
+                outputs=[out_info],
+                value_info=[x_info],
+            )
+            return subgraph, out_name
+
+        # Otherwise, this node is a split
+        cond_name = _unique_name("cond_bool")
+        is_oblique = node_dict.get("is_oblique", False)
+        cat_list = node_dict.get("category_left", [])
+        n_category = len(cat_list)
+
+        # Oblique split
+        if is_oblique:
+            w_list = node_dict["weights"]
+            f_list = node_dict["features"]
+            thr_val = node_dict["threshold"]
+
+            partials = []
+            for w, f_idx in zip(w_list, f_list):
+                gather_idx = _make_constant_int_node(
+                    _unique_name("gather_idx"), [f_idx], [1]
+                )
+                nodes.append(gather_idx)
+
+                gather_out = _unique_name("gather_out")
+                gnode = helper.make_node(
+                    "Gather",
+                    inputs=["X", gather_idx.output[0]],
+                    outputs=[gather_out],
+                    axis=0,
+                )
+                nodes.append(gnode)
+
+                w_node = _make_constant_float_node(_unique_name("weight"), w, [])
+                nodes.append(w_node)
+
+                mul_out = _unique_name("mul_out")
+                mul_node = helper.make_node(
+                    "Mul", inputs=[gather_out, w_node.output[0]], outputs=[mul_out]
+                )
+                nodes.append(mul_node)
+                partials.append(mul_out)
+
+            # Summation of partial products
+            if len(partials) == 1:
+                final_dot = partials[0]
+            else:
+                tmp = partials[0]
+                for p in partials[1:]:
+                    add_out = _unique_name("add_out")
+                    add_node = helper.make_node(
+                        "Add", inputs=[tmp, p], outputs=[add_out]
+                    )
+                    nodes.append(add_node)
+                    tmp = add_out
+                final_dot = tmp
+
+            thr_node = _make_constant_float_node(_unique_name("thr"), thr_val, [])
+            nodes.append(thr_node)
+
+            less_node = helper.make_node(
+                "Less", inputs=[final_dot, thr_node.output[0]], outputs=[cond_name]
+            )
+            nodes.append(less_node)
+
+        # Categorical split
+        elif n_category > 0:
+            f_idx = node_dict["feature_idx"]
+            fnode = _make_constant_int_node(_unique_name("catf_idx"), [f_idx], [1])
+            nodes.append(fnode)
+
+            gout = _unique_name("cat_gather_out")
+            gnode = helper.make_node(
+                "Gather", inputs=["X", fnode.output[0]], outputs=[gout], axis=0
+            )
+            nodes.append(gnode)
+
+            eq_outputs = []
+            for c_val in cat_list:
+                cat_node = _make_constant_float_node(_unique_name("cat_val"), c_val, [])
+                nodes.append(cat_node)
+
+                eq_out = _unique_name("eq_out")
+                eq_node = helper.make_node(
+                    "Equal", inputs=[gout, cat_node.output[0]], outputs=[eq_out]
+                )
+                nodes.append(eq_node)
+                eq_outputs.append(eq_out)
+
+            if len(eq_outputs) == 1:
+                final_eq = eq_outputs[0]
+            else:
+                tmp = eq_outputs[0]
+                for eqo in eq_outputs[1:]:
+                    or_out = _unique_name("or_out")
+                    or_node = helper.make_node(
+                        "Or", inputs=[tmp, eqo], outputs=[or_out]
+                    )
+                    nodes.append(or_node)
+                    tmp = or_out
+                final_eq = tmp
+
+            id_node = helper.make_node(
+                "Identity", inputs=[final_eq], outputs=[cond_name]
+            )
+            nodes.append(id_node)
+
+        # Axis-aligned numeric split
+        else:
+            f_idx = node_dict["feature_idx"]
+            thr_val = node_dict["threshold"]
+
+            fnode = _make_constant_int_node(_unique_name("f_idx"), [f_idx], [1])
+            nodes.append(fnode)
+
+            gout = _unique_name("gather_out")
+            gnode = helper.make_node(
+                "Gather", inputs=["X", fnode.output[0]], outputs=[gout], axis=0
+            )
+            nodes.append(gnode)
+
+            thr_node = _make_constant_float_node(_unique_name("thr_val"), thr_val, [])
+            nodes.append(thr_node)
+
+            less_node = helper.make_node(
+                "Less", inputs=[gout, thr_node.output[0]], outputs=[cond_name]
+            )
+            nodes.append(less_node)
+
+        # Recursively build subgraphs for left and right
+        left_sub, left_out = _build_subgraph_for_node(node_dict["left"], n_classes)
+        right_sub, right_out = _build_subgraph_for_node(node_dict["right"], n_classes)
+
+        if_out = _unique_name("if_out")
+        if_info = helper.make_tensor_value_info(if_out, TensorProto.DOUBLE, None)
+
+        if_node = helper.make_node(
+            "If",
+            inputs=[cond_name],
+            outputs=[if_out],
+            name=_unique_name("IfNode"),
+            then_branch=left_sub,
+            else_branch=right_sub,
+        )
+        nodes.append(if_node)
+
+        subgraph = helper.make_graph(
+            nodes=nodes,
+            name=graph_name,
+            inputs=[],
+            outputs=[if_info],
+            value_info=[x_info],
+        )
+        return subgraph, if_out
+
+    # Retrieve tree parameters
+    params = tree_dict["params"]
+    n_classes = params.get("n_classes", 2)
+    n_features = params.get("n_features", 4)
+
+    # Build the root subgraph from the tree
+    root_subgraph, root_out_name = _build_subgraph_for_node(
+        tree_dict["tree"], n_classes
+    )
+
+    # Main graph I/O
+    main_input = helper.make_tensor_value_info("X", TensorProto.DOUBLE, [n_features])
+    main_output = helper.make_tensor_value_info("Y", TensorProto.DOUBLE, None)
+
+    # Extract nodes and value_info from the root subgraph
+    nodes = list(root_subgraph.node)
+    val_info = list(root_subgraph.value_info)
+    if_out_name = root_subgraph.output[0].name
+
+    # Add a final Identity node to map subgraph output to "Y"
+    final_out_node_name = _unique_name("final_y")
+    identity_node = helper.make_node(
+        "Identity", inputs=[if_out_name], outputs=[final_out_node_name]
+    )
+    nodes.append(identity_node)
+    main_output.name = final_out_node_name
+
+    # Construct the main graph
+    main_graph = helper.make_graph(
+        nodes=nodes,
+        name="MainGraph",
+        inputs=[main_input],
+        outputs=[main_output],
+        value_info=val_info,
+    )
+
+    # Fix output shape to [1] or [n_classes]
+    if n_classes > 2:
+        dim = main_graph.output[0].type.tensor_type.shape.dim.add()
+        dim.dim_value = n_classes
+    else:
+        dim = main_graph.output[0].type.tensor_type.shape.dim.add()
+        dim.dim_value = 1
+
+    # Fix input shape to [n_features]
+    main_graph.input[0].type.tensor_type.shape.dim[0].dim_value = n_features
+
+    onnx_model = helper.make_model(
+        main_graph,
+        producer_name="custom_oblique_categorical_tree",
+        opset_imports=[helper.make_opsetid("", 13)],
+    )
+    onnx_model.ir_version = 7
+
+    return onnx_model
 
 
 def _format_float(value: float) -> str:

{obliquetree-1.0.1.dist-info → obliquetree-1.0.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: obliquetree
-Version: 1.0.1
+Version: 1.0.3
 Summary: Traditional and Oblique Decision Tree
 Author-email: Samet Copur <sametcopur@yahoo.com>
 License: MIT License
@@ -16,6 +16,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy>=2.2.1
 Requires-Dist: scipy>=1.15.0
+Dynamic: license-file
 
 # obliquetree
 

obliquetree-1.0.3.dist-info/RECORD

@@ -0,0 +1,21 @@
+obliquetree/__init__.py,sha256=Dx8l4yy_b_7HPRYpkz39tiKcLBtoS4HsWXOwz1VpiGc,106
+obliquetree/_pywrap.py,sha256=iz7FI7u8MP_iLKiGRtBaEfsw_dnpK8epxLJCI1T8XUw,27079
+obliquetree/utils.py,sha256=ewYp_3HZRvgBMysMlnelZdDuMCv49wsPAuYD_6du4GY,31149
+obliquetree/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+obliquetree/src/base.cp313-win_amd64.pyd,sha256=Gl6jx5itauxWVSPCTNP_Tb4uGAd-O7oaOibLq62EHog,178176
+obliquetree/src/base.cpp,sha256=IwnIkavQxfU0cC4-AVjPN-5aSHgnCjtOm4K88R156UE,1455964
+obliquetree/src/ccp.cp313-win_amd64.pyd,sha256=LQqRsSBycCUF2ixiwKJGbUji3BH3wuB3twSOU2zcuvg,107520
+obliquetree/src/ccp.cpp,sha256=t46G1BB4xXnUPYirTU1g3-vy75f8Y77iwOoXu-svsk8,974220
+obliquetree/src/metric.cp313-win_amd64.pyd,sha256=zRuRAglR5fuyogpS1w4sYiwzgsUZ29r6QfVZtO5S2FM,128512
+obliquetree/src/metric.cpp,sha256=L-nfMk16gP5BQqiqC-TRguNjOgqSKnhDHRZbZRnbMkA,1214827
+obliquetree/src/oblique.cp313-win_amd64.pyd,sha256=fPcIzM2Bbkf19LgWXCza1fR9qzSJIFq67_-2jRoTlU8,201216
+obliquetree/src/oblique.cpp,sha256=M-vcBquzSJ0lGx0cY63g6WnV13GnpVGBjTXDeRpw-co,1402472
+obliquetree/src/tree.cp313-win_amd64.pyd,sha256=U_ZYjKsGI6-Qz5ogCmmXstLQTDi0neAi85BxjpKgruI,121344
+obliquetree/src/tree.cpp,sha256=VVPtQxz8Qq0kJb1uAne_dB9Q_qUXPEmc2BwumlYqFIw,1164673
+obliquetree/src/utils.cp313-win_amd64.pyd,sha256=I7ZOJZ-akf6uvJEpZZXc38BarkD5SDBB8_4sBR09NOw,159744
+obliquetree/src/utils.cpp,sha256=FhJTiyLfEKZeYB78f_n08L13mHyN4IJskoQ9gwv64ww,1268066
+obliquetree-1.0.3.dist-info/licenses/LICENSE,sha256=WfEPDyxevjVRSepuK7Lvl2VDl5pqtwjvMoNu2iWhcD8,1090
+obliquetree-1.0.3.dist-info/METADATA,sha256=gRRugN8nEvyw9a-_SDWNQ-cwZXziJp5Xo8kvH9ogBmc,5776
+obliquetree-1.0.3.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
+obliquetree-1.0.3.dist-info/top_level.txt,sha256=m-5N4-iAS5MsFOdk8y1r2ya_i5rVQBgPayHBA-K26qg,12
+obliquetree-1.0.3.dist-info/RECORD,,

{obliquetree-1.0.1.dist-info → obliquetree-1.0.3.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp313-cp313-win_amd64
 

obliquetree-1.0.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-obliquetree/__init__.py,sha256=facekeN72UJTEDPLHy4qMR3gREAZ7GPa3vG4TyHKa0w,83
-obliquetree/_pywrap.py,sha256=xFbIFoMNAAYyDSO6b5A1NytxA5eV8-KxXgF2wxbysWo,26484
-obliquetree/utils.py,sha256=U0aRNA_FxiIiEagABAAQZ1Ssx1nIMdo-XjN3qv7V98w,18502
-obliquetree/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-obliquetree/src/base.cp313-win_amd64.pyd,sha256=6463FQS9jjxbrfOseDnOgdLwyYgQe8XPRxW15S8wJts,193536
-obliquetree/src/base.cpp,sha256=0ZILP5yX1ixNIfIn6FDiSmQdTakW1VI1qk-OEmOmec4,1421617
-obliquetree/src/ccp.cp313-win_amd64.pyd,sha256=5rmHkpVJl6PA_vPa7_Hr6Rl-v5khtedgoz7bar_GZ9k,118272
-obliquetree/src/ccp.cpp,sha256=sAmjaZwmzsSBbj35VMJ3H5FBB18vJRjNjeHDvQXQ3Og,944547
-obliquetree/src/metric.cp313-win_amd64.pyd,sha256=hWLdoiDmNZ_scv3F4Su1I_8plqFy1V8rOA2T219z1zw,136704
-obliquetree/src/metric.cpp,sha256=XmHbXjazt8upGm4pejkF4cqHjDQR1xY-0X00H3jrXxk,1174026
-obliquetree/src/oblique.cp313-win_amd64.pyd,sha256=i09mWgrHL4BTWhyQPkt-A9yDPISGurXdDW9NySedqa4,210432
-obliquetree/src/oblique.cpp,sha256=eXd3pS6_mE2w9xLzgx3QXo4S64dNUH2CGPoanUtPCp8,1353669
-obliquetree/src/tree.cp313-win_amd64.pyd,sha256=4u6mBgaqdW3a1XK9RsSZVyr_8F8BrkKcBG78yo9jVR4,132608
-obliquetree/src/tree.cpp,sha256=54KJ8my79R9h4JS6cb1rZ09HXt9IbMy0JtJkKj5vLE8,1130952
-obliquetree/src/utils.cp313-win_amd64.pyd,sha256=KxACVs9GSijGykwzTtJ0SFxB845CAXZQ3KPP6GHT7g8,171520
-obliquetree/src/utils.cpp,sha256=eEPf0KdnQoD1-CqVeOM57ElLOQIXvgt5KRhqFP-aygY,1227801
-obliquetree-1.0.1.dist-info/LICENSE,sha256=WfEPDyxevjVRSepuK7Lvl2VDl5pqtwjvMoNu2iWhcD8,1090
-obliquetree-1.0.1.dist-info/METADATA,sha256=Shil4GEgde1VDY0cBdvglKurdxy9SBoEWZJoZkaeG4Q,5753
-obliquetree-1.0.1.dist-info/WHEEL,sha256=6bXTkCllrWLYPW3gCPkeRA91N4604g9hqNhQqZWsUzQ,101
-obliquetree-1.0.1.dist-info/top_level.txt,sha256=m-5N4-iAS5MsFOdk8y1r2ya_i5rVQBgPayHBA-K26qg,12
-obliquetree-1.0.1.dist-info/RECORD,,