obliquetree 1.0.1__cp313-cp313-macosx_11_0_arm64.whl → 1.0.3__cp313-cp313-macosx_11_0_arm64.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-1.0.3.dist-info/RECORD,,
+obliquetree-1.0.3.dist-info/WHEEL,sha256=oqGJCpG61FZJmvyZ3C_0aCv-2mdfcY9e3fXvyUNmWfM,136
+obliquetree-1.0.3.dist-info/top_level.txt,sha256=m-5N4-iAS5MsFOdk8y1r2ya_i5rVQBgPayHBA-K26qg,12
+obliquetree-1.0.3.dist-info/METADATA,sha256=zo1UGljAQo1gfqG3q4-X1L4A4xIUf6UUAaiRQaDlfL4,5662
+obliquetree-1.0.3.dist-info/licenses/LICENSE,sha256=lLpW3hLh8QbaRAWXRaZ76c80HoVfUr6739D0S7ecslU,1069
+obliquetree/__init__.py,sha256=VQapTBiRrm5l9oV8X2fu3xlvvGTh1cjQ6Hh3ynpArKU,103
+obliquetree/utils.py,sha256=mEs3ZspxOKUm1SoS-ms0XjQQ1Ci6Ej4oQA53WEYY7VY,30267
+obliquetree/_pywrap.py,sha256=d6XRinPMBxNUf2UlJQkV4TOe3_zbEcM4q8j8QPcXudg,26332
+obliquetree/src/oblique.cpython-313-darwin.so,sha256=qHhszVSrcdkucKUPH6cZ5so8Pg1gen6Rp98r88O3xlQ,274992
+obliquetree/src/utils.cpython-313-darwin.so,sha256=wcpcl6NTWSGg46gCXDozStcRF4I6M3QR8kkArV5cPf0,241000
+obliquetree/src/utils.cpp,sha256=m5yKWGT2Raa-Hp0l3WnJTvVBAE1ffXHP4mHm2HPtq0o,1235475
+obliquetree/src/oblique.cpp,sha256=m-r8KzSYciId_fLv_6RpiDnfgUYI6jzAc39nAEfHLPw,1373446
+obliquetree/src/tree.cpython-313-darwin.so,sha256=3KnklQokc3Mx5pmBLMVwxe_48HhWalFGmfpneAUDKJQ,186456
+obliquetree/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+obliquetree/src/metric.cpython-313-darwin.so,sha256=RdJbO5EV_9U7WClcUVmtMqYOxwtG5PIAeSnFkPxl7bs,186576
+obliquetree/src/base.cpp,sha256=iuMgZPW5MgmoN5mrO7OJVvxJ2QptoHnIE48uWUN7n3c,1425867
+obliquetree/src/tree.cpp,sha256=iu-sVurOM8JaPejum9zOKDnbbHZ-aP7xu6hN1bDOFM4,1140593
+obliquetree/src/base.cpython-313-darwin.so,sha256=CbtY_Sp42d_IfvBGXviSN__XVwjHQL-LCmMFspF57PY,237768
+obliquetree/src/metric.cpp,sha256=teggi4m4sPU-x9Qp_OgzvgUr0DoRhlsy68znBWI6Qfk,1183025
+obliquetree/src/ccp.cpython-313-darwin.so,sha256=QkbcRVGwFjnOmnwmRFRlegPJ43YnD8UXGU3aGHAS3-c,168744
+obliquetree/src/ccp.cpp,sha256=O37o5Srj3pXCqPQTZNcONTZh8KWQzx1faUzxweY5IWw,948593

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

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

obliquetree-1.0.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-obliquetree-1.0.1.dist-info/RECORD,,
-obliquetree-1.0.1.dist-info/LICENSE,sha256=lLpW3hLh8QbaRAWXRaZ76c80HoVfUr6739D0S7ecslU,1069
-obliquetree-1.0.1.dist-info/WHEEL,sha256=zEwrEM3mH_qOUQ9uk3aZI5DMOaUao9_e1G94mKtHrTY,109
-obliquetree-1.0.1.dist-info/top_level.txt,sha256=m-5N4-iAS5MsFOdk8y1r2ya_i5rVQBgPayHBA-K26qg,12
-obliquetree-1.0.1.dist-info/METADATA,sha256=_6KQMjXzPh7zw-b0KVnGB9hWUziugEiy_ZUUgaZIfrU,5640
-obliquetree/__init__.py,sha256=hER789IcI7j2GnsVNvUhdVUjPJemBfHd2ztSOZgRwW8,81
-obliquetree/utils.py,sha256=coNk6PATedhTTBoapJ6rb0SI4TSfRYxI6bBnGAwAO_Y,17976
-obliquetree/_pywrap.py,sha256=pzx9tUbzb_4Brw6UOgYFVMv9VIfupDkJBLh5m1tUTEo,25754
-obliquetree/src/oblique.cpython-313-darwin.so,sha256=IYByqU32n9dV4r8M7h8aNlx1At5aYB-ElE53ivFUcXY,274208
-obliquetree/src/utils.cpython-313-darwin.so,sha256=4R9oI5ewInY43Ad-BgAs7bW_xg99sFdmwKf-x7lzuPw,255368
-obliquetree/src/utils.cpp,sha256=PfMduDxsBsXgqTLtKnSR64AwpFMxdjUjt_JXNI4qZ5k,1227838
-obliquetree/src/oblique.cpp,sha256=BuWau7O_ss6UBXksB9lUnnKRzubpqG7jlKNCw46gfZI,1360036
-obliquetree/src/tree.cpython-313-darwin.so,sha256=bZ9PsC2QIP7RcMsqkAmnbrWFSPkhjf_9I5cZEYFoxCw,186104
-obliquetree/src/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-obliquetree/src/metric.cpython-313-darwin.so,sha256=gxuuGqhOGm8VfmtmNPqzUva_Y7V6HVZ55x60aLTduKo,186272
-obliquetree/src/base.cpp,sha256=3qTjAymCfj6DMaMgQIs4oy7es_be8gvR-0rjizM3xHg,1427982
-obliquetree/src/tree.cpp,sha256=eGG_uEGMFvShxueZkh9q-aPn2aYdfo0a68lfhcn58oE,1137319
-obliquetree/src/base.cpython-313-darwin.so,sha256=qoQipqhUHNz7o3jHh6jML09Ze6elc1CFemOl-K1juu4,251944
-obliquetree/src/metric.cpp,sha256=SpEtL7DpYOA-InNAzZ5dlaf4ArfrQ5uPHeQ0ohG-x-U,1174065
-obliquetree/src/ccp.cpython-313-darwin.so,sha256=7wUp4lqKcSP9hLi6RpJ_S37wZGh1f4tfFLH5apAcN-0,168520
-obliquetree/src/ccp.cpp,sha256=7pzrXKC1QwIxE68Ew_EEft8QBx-Zwb053s3wKEdoOoc,944586