如何导入预定义文本格式决策树作为分类器？求现有实现方案

Great question! It’s totally understandable to want to avoid reinventing the wheel when you’ve already got the parsing logic working. Let’s go through some practical existing tools and libraries that let you load a pre-defined decision tree structure for predictions, instead of training one from scratch:

1. XGBoost (Supports Custom Tree Construction) #

XGBoost is a popular gradient boosting library that lets you manually define tree structures or import them from external formats. You can leverage its low-level API to build trees node-by-node using your parsed conditions, or convert your tree text into XGBoost’s native model format (like JSON or binary .model files).

Once you’ve parsed each node’s level, condition, and target value, you can construct an XGBoost Booster by mapping your tree structure to its compatible format. XGBoost’s documentation details its internal tree representation, but a straightforward approach is to build the tree incrementally with its API, then use booster.predict() to generate predictions.

2. LightGBM (Flexible Model Loading for Custom Trees) #

LightGBM works similarly to XGBoost and supports loading pre-defined models via its model_from_string() method. If you can convert your parsed tree into LightGBM’s human-readable model string format, you can directly load it into a Booster object and start making predictions.

This is ideal if you want to integrate your custom tree with other LightGBM features like regularization or optimized inference pipelines.

3. treelib (Lightweight Tree Structure Tool) #

If you don’t need full machine learning library features and just want clean tree traversal logic, treelib is a perfect match. It’s a simple Python library for creating and managing tree structures, which pairs seamlessly with your existing parser.

Here’s a quick example of how to use it:

from treelib import Tree

# Initialize tree and populate with parsed nodes
tree = Tree()
tree.create_node("Root", "root")  # Root node (level 0)

# Assume parsed_nodes is your list of (level, condition) tuples
for level, condition in parsed_nodes:
    # Logic to find parent node based on hierarchy level
    parent_id = determine_parent_id(level)  # Implement this based on your tree's structure
    node_id = f"{condition['field']}_{condition['statement']}_{condition['value']}"
    node_label = f"{condition['field']} {condition['statement']} {condition['value']}"
    
    # Add node to tree
    tree.create_node(node_label, node_id, parent=parent_id)
    # Store target value in node data if it's a leaf
    if 'target' in condition:
        tree.get_node(node_id).data = {'target': float(condition['target'])}

# Prediction function to traverse the tree
def predict(obj, current_node_id="root"):
    current_node = tree.get_node(current_node_id)
    # Return target if it's a leaf node
    if 'target' in current_node.data:
        return current_node.data['target']
    
    # Evaluate condition to find the correct child node
    field = condition['field']
    statement = condition['statement']
    value = condition['value']
    obj_value = obj[field]

    # Handle condition types ('in' and '<=')
    if statement == '<=':
        threshold = float(value.strip())
        child_id = get_child_for_leq(current_node_id)  # Map condition result to child node
    elif statement == 'in':
        allowed_values = [v.strip('" ') for v in value.strip('[]').split(',')]
        if obj_value in allowed_values:
            child_id = get_child_for_match(current_node_id)
    
    # Recurse into the child node
    return predict(obj, child_id)

This way, you skip writing all the tree traversal logic from scratch, and treelib handles hierarchy management for you.

4. Hacking scikit-learn's DecisionTree (Advanced, Version-Dependent) #

While scikit-learn doesn’t officially support loading custom trees, you can manually modify the internal tree_ attribute of a DecisionTreeClassifier object. This is a bit of a hack, but it works if you need to use scikit-learn’s interface for consistency.

scikit-learn’s tree is stored as a set of arrays in clf.tree_, including:

• node_count: Total number of nodes
• children_left/children_right: Indices of left/right children for each node
• feature: Index of the feature used for splitting at non-leaf nodes
• threshold: Threshold value for the split
• value: Target value for leaf nodes

You’d map your parsed tree structure into these arrays like so:

from sklearn.tree import DecisionTreeClassifier
import numpy as np

clf = DecisionTreeClassifier()
# Initialize arrays based on your tree's structure
clf.tree_.node_count = your_total_nodes
clf.tree_.children_left = np.array([...], dtype=np.int64)
clf.tree_.children_right = np.array([...], dtype=np.int64)
clf.tree_.feature = np.array([...], dtype=np.int64)
clf.tree_.threshold = np.array([...], dtype=np.float64)
clf.tree_.value = np.array([[[target_val]] for ...], dtype=np.float64)

Note: This method is fragile because scikit-learn’s internal tree structure can change between versions. Use it only if you’re working with a stable scikit-learn version and don’t need frequent updates.

Recommendation #

If you want a simple, low-maintenance solution, go with treelib—it’s lightweight and integrates smoothly with your existing parser. If you need to integrate with other machine learning workflows or optimize inference, XGBoost or LightGBM are better choices. The scikit-learn hack is a last resort if you must use its API.

内容的提问来源于stack exchange，提问作者Oleh Rybalchenko