entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/tree/export.py|blocks|key|8vbd0|text|from+StringIO+import+StringIO
out+=+StringIO()
out+=+tree.export_graphviz(clf,+out_file=out)
print+out.getvalue()|code-block|depth|inlineStyleRanges|entityRanges|syntax|javascript|4aae6|你可以看到一个有向图树。然后，clf.tree_.feature和clf.tree_.value分别是节点拆分特征数组和节点值数组。你可以从这里参考更多的细节。|unstyled|offset|length|style|CODE|b577v|github+source.+|UNDERLINE^0|0|F|H|X|F|0|0|D|0|D|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|U|G|@]|H|@]|6|$I|J]]|$A|K|C|L|2|M|F|V|G|@$N|W|O|X|P|Q]|$N|Y|O|Z|P|Q]]|H|@]|6|$]]|$A|R|C|S|2|M|F|10|G|@$N|11|O|12|P|T]]|H|@$N|13|O|14|A|15]]|6|$]]]]

<pre><code>from StringIO import StringIO
out = StringIO()
out = tree.export_graphviz(clf, out_file=out)
print out.getvalue()
</code></pre>

You can see a digraph Tree. Then, <code>clf.tree_.feature</code> and <code>clf.tree_.value</code> are array of nodes splitting feature and array of nodes values respectively. You can refer to more details from this <a href="https://github.com/scikit-learn/scikit-learn/blob/master/sklearn/tree/export.py">github source</a>.

entityMap|0|type|IMAGE|mutability|IMMUTABLE|data|imageUrl|https://ask.qcloudimg.com/http-save/actteam/82bea665b1ea8645020d27aeb6eba028.png|imageAlt|blocks|key|1men5|text|我创建了自己的函数来从sklearn创建的决策树中提取规则：|unstyled|depth|inlineStyleRanges|entityRanges|erbo9|import+pandas+as+pd
import+numpy+as+np
from+sklearn.tree+import+DecisionTreeClassifier

#+dummy+data:
df+=+pd.DataFrame({'col1':[0,1,2,3],'col2':[3,4,5,6],'dv':[0,1,0,1]})

#+create+decision+tree
dt+=+DecisionTreeClassifier(max_depth=5,+min_samples_leaf=1)
dt.fit(df.ix[:,:2],+df.dv)|code-block|syntax|javascript|bsg8n|此函数首先从节点(在子数组中由-1标识)开始，然后递归查找父节点。我称之为节点的“谱系”。在此过程中，我获取了需要创建if/then/else+SAS逻辑的值：|m0uq|def+get_lineage(tree,+feature_names):
+++++left++++++=+tree.tree_.children_left
+++++right+++++=+tree.tree_.children_right
+++++threshold+=+tree.tree_.threshold
+++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]

+++++#+get+ids+of+child+nodes
+++++idx+=+np.argwhere(left+==+-1)[:,0]+++++

+++++def+recurse(left,+right,+child,+lineage=None):++++++++++
++++++++++if+lineage+is+None:
+++++++++++++++lineage+=+[child]
++++++++++if+child+in+left:
+++++++++++++++parent+=+np.where(left+==+child)[0].item()
+++++++++++++++split+=+'l'
++++++++++else:
+++++++++++++++parent+=+np.where(right+==+child)[0].item()
+++++++++++++++split+=+'r'

++++++++++lineage.append((parent,+split,+threshold[parent],+features[parent]))

++++++++++if+parent+==+0:
+++++++++++++++lineage.reverse()
+++++++++++++++return+lineage
++++++++++else:
+++++++++++++++return+recurse(left,+right,+parent,+lineage)

+++++for+child+in+idx:
++++++++++for+node+in+recurse(left,+right,+child):
+++++++++++++++print+node|bh2gg|下面的元组集包含创建SAS+if/then/else语句所需的所有内容。我不喜欢用do块，这就是我创建描述节点整个路径的逻辑的原因。元组后面的单个整数是路径中终端节点的ID。前面的所有元组组合在一起创建该节点。|offset|length|style|CODE|c1dq6|In+[1]:+get_lineage(dt,+df.columns)
(0,+'l',+0.5,+'col1')
1
(0,+'r',+0.5,+'col1')
(2,+'l',+4.5,+'col2')
3
(0,+'r',+0.5,+'col1')
(2,+'r',+4.5,+'col2')
(4,+'l',+2.5,+'col1')
5
(0,+'r',+0.5,+'col1')
(2,+'r',+4.5,+'col2')
(4,+'r',+2.5,+'col1')
6|1tf11|​|aj6vq|2g2ed|?|atomic|e8gve|qa4h^0|0|0|0|0|15|2|0|0|0|0|0|1|0|0|0^^$0|$1|$2|3|4|5|6|$7|8|9|-4]]]|A|@$B|C|D|E|2|F|G|18|H|@]|I|@]|6|$]]|$B|J|D|K|2|L|G|19|H|@]|I|@]|6|$M|N]]|$B|O|D|P|2|F|G|1A|H|@]|I|@]|6|$]]|$B|Q|D|R|2|L|G|1B|H|@]|I|@]|6|$M|N]]|$B|S|D|T|2|F|G|1C|H|@$U|1D|V|1E|W|X]]|I|@]|6|$]]|$B|Y|D|Z|2|L|G|1F|H|@]|I|@]|6|$M|N]]|$B|10|D|11|2|F|G|1G|H|@]|I|@]|6|$]]|$B|12|D|-4|2|F|G|1H|H|@]|I|@]|6|$]]|$B|13|D|14|2|15|G|1I|H|@]|I|@$U|1J|V|1K|B|1L]]|6|$]]|$B|16|D|-4|2|F|G|1M|H|@]|I|@]|6|$]]|$B|17|D|11|2|F|G|1N|H|@]|I|@]|6|$]]]]

I created my own function to extract the rules from the decision trees created by sklearn:

<pre><code>import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier

# dummy data:
df = pd.DataFrame({'col1':[0,1,2,3],'col2':[3,4,5,6],'dv':[0,1,0,1]})

# create decision tree
dt = DecisionTreeClassifier(max_depth=5, min_samples_leaf=1)
dt.fit(df.ix[:,:2], df.dv)
</code></pre>

This function first starts with the nodes (identified by -1 in the child arrays) and then recursively finds the parents. I call this a node's 'lineage'. Along the way, I grab the values I need to create if/then/else SAS logic:

<pre><code>def get_lineage(tree, feature_names):
 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 features = [feature_names[i] for i in tree.tree_.feature]

 # get ids of child nodes
 idx = np.argwhere(left == -1)[:,0] 

 def recurse(left, right, child, lineage=None): 
 if lineage is None:
 lineage = [child]
 if child in left:
 parent = np.where(left == child)[0].item()
 split = 'l'
 else:
 parent = np.where(right == child)[0].item()
 split = 'r'

 lineage.append((parent, split, threshold[parent], features[parent]))

 if parent == 0:
 lineage.reverse()
 return lineage
 else:
 return recurse(left, right, parent, lineage)

 for child in idx:
 for node in recurse(left, right, child):
 print node
</code></pre>

The sets of tuples below contain everything I need to create SAS if/then/else statements. I do not like using <code>do</code> blocks in SAS which is why I create logic describing a node's entire path. The single integer after the tuples is the ID of the terminal node in a path. All of the preceding tuples combine to create that node.

<pre><code>In [1]: get_lineage(dt, df.columns)
(0, 'l', 0.5, 'col1')
1
(0, 'r', 0.5, 'col1')
(2, 'l', 4.5, 'col2')
3
(0, 'r', 0.5, 'col1')
(2, 'r', 4.5, 'col2')
(4, 'l', 2.5, 'col1')
5
(0, 'r', 0.5, 'col1')
(2, 'r', 4.5, 'col2')
(4, 'r', 2.5, 'col1')
6
</code></pre>

<img src="https://i.stack.imgur.com/SWwtO.png" alt="GraphViz output of example tree">

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://stackoverflow.com/users/919872/zelazny7|blocks|key|1shu6|text|我修改了提交的代码Zelazny7要打印一些伪代码，请执行以下操作：|unstyled|depth|inlineStyleRanges|offset|length|style|UNDERLINE|entityRanges|4l983|def+get_code(tree,+feature_names):
++++++++left++++++=+tree.tree_.children_left
++++++++right+++++=+tree.tree_.children_right
++++++++threshold+=+tree.tree_.threshold
++++++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]
++++++++value+=+tree.tree_.value

++++++++def+recurse(left,+right,+threshold,+features,+node):
++++++++++++++++if+(threshold[node]+!=+-2):
++++++++++++++++++++++++print+"if+(+"+%2B+features[node]+%2B+"+<=+"+%2B+str(threshold[node])+%2B+"+)+{"
++++++++++++++++++++++++if+left[node]+!=+-1:
++++++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,left[node])
++++++++++++++++++++++++print+"}+else+{"
++++++++++++++++++++++++if+right[node]+!=+-1:
++++++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,right[node])
++++++++++++++++++++++++print+"}"
++++++++++++++++else:
++++++++++++++++++++++++print+"return+"+%2B+str(value[node])

++++++++recurse(left,+right,+threshold,+features,+0)|code-block|syntax|javascript|bt0t4|如果你调用get_code(dt,+df.columns)在同一示例中，您将获得：|CODE|5maj3|if+(+col1+<=+0.5+)+{
return+[[+1.++0.]]
}+else+{
if+(+col2+<=+4.5+)+{
return+[[+0.++1.]]
}+else+{
if+(+col1+<=+2.5+)+{
return+[[+1.++0.]]
}+else+{
return+[[+0.++1.]]
}
}
}^0|9|8|9|8|0|0|0|5|O|5|O|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|W|G|@$H|X|I|Y|J|K]]|L|@$H|Z|I|10|A|11]]|6|$]]|$A|M|C|N|2|O|F|12|G|@]|L|@]|6|$P|Q]]|$A|R|C|S|2|E|F|13|G|@$H|14|I|15|J|K]|$H|16|I|17|J|T]]|L|@]|6|$]]|$A|U|C|V|2|O|F|18|G|@]|L|@]|6|$P|Q]]]]

I modified the code submitted by <a href="https://stackoverflow.com/users/919872/zelazny7">Zelazny7</a> to print some pseudocode:

<pre><code>def get_code(tree, feature_names):
 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 features = [feature_names[i] for i in tree.tree_.feature]
 value = tree.tree_.value

 def recurse(left, right, threshold, features, node):
 if (threshold[node] != -2):
 print "if ( " + features[node] + " &lt;= " + str(threshold[node]) + " ) {"
 if left[node] != -1:
 recurse (left, right, threshold, features,left[node])
 print "} else {"
 if right[node] != -1:
 recurse (left, right, threshold, features,right[node])
 print "}"
 else:
 print "return " + str(value[node])

 recurse(left, right, threshold, features, 0)
</code></pre>

if you call <code>get_code(dt, df.columns)</code> on the same example you will obtain:

<pre><code>if ( col1 &lt;= 0.5 ) {
return [[ 1. 0.]]
} else {
if ( col2 &lt;= 4.5 ) {
return [[ 0. 1.]]
} else {
if ( col1 &lt;= 2.5 ) {
return [[ 1. 0.]]
} else {
return [[ 0. 1.]]
}
}
}
</code></pre>

entityMap|blocks|key|eie88|text|这是一个函数，在python+3下打印scikit-learn决策树的规则，并带有条件块的偏移量，以使结构更具可读性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4uvfn|def+print_decision_tree(tree,+feature_names=None,+offset_unit='++++'):
++++'''Plots+textual+representation+of+rules+of+a+decision+tree
++++tree:+scikit-learn+representation+of+tree
++++feature_names:+list+of+feature+names.+They+are+set+to+f1,f2,f3,...+if+not+specified
++++offset_unit:+a+string+of+offset+of+the+conditional+block'''

++++left++++++=+tree.tree_.children_left
++++right+++++=+tree.tree_.children_right
++++threshold+=+tree.tree_.threshold
++++value+=+tree.tree_.value
++++if+feature_names+is+None:
++++++++features++=+['f%25d'%25i+for+i+in+tree.tree_.feature]
++++else:
++++++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]++++++++

++++def+recurse(left,+right,+threshold,+features,+node,+depth=0):
++++++++++++offset+=+offset_unit*depth
++++++++++++if+(threshold[node]+!=+-2):
++++++++++++++++++++print(offset%2B"if+(+"+%2B+features[node]+%2B+"+<=+"+%2B+str(threshold[node])+%2B+"+)+{")
++++++++++++++++++++if+left[node]+!=+-1:
++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,left[node],depth%2B1)
++++++++++++++++++++print(offset%2B"}+else+{")
++++++++++++++++++++if+right[node]+!=+-1:
++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,right[node],depth%2B1)
++++++++++++++++++++print(offset%2B"}")
++++++++++++else:
++++++++++++++++++++print(offset%2B"return+"+%2B+str(value[node]))

++++recurse(left,+right,+threshold,+features,+0,0)|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Here is a function, printing rules of a scikit-learn decision tree under python 3 and with offsets for conditional blocks to make the structure more readable:

<pre><code>def print_decision_tree(tree, feature_names=None, offset_unit=' '):
 '''Plots textual representation of rules of a decision tree
 tree: scikit-learn representation of tree
 feature_names: list of feature names. They are set to f1,f2,f3,... if not specified
 offset_unit: a string of offset of the conditional block'''

 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 value = tree.tree_.value
 if feature_names is None:
 features = ['f%d'%i for i in tree.tree_.feature]
 else:
 features = [feature_names[i] for i in tree.tree_.feature] 

 def recurse(left, right, threshold, features, node, depth=0):
 offset = offset_unit*depth
 if (threshold[node] != -2):
 print(offset+"if ( " + features[node] + " &lt;= " + str(threshold[node]) + " ) {")
 if left[node] != -1:
 recurse (left, right, threshold, features,left[node],depth+1)
 print(offset+"} else {")
 if right[node] != -1:
 recurse (left, right, threshold, features,right[node],depth+1)
 print(offset+"}")
 else:
 print(offset+"return " + str(value[node]))

 recurse(left, right, threshold, features, 0,0)
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://i.stack.imgur.com/OqHfU.png|blocks|key|cgooc|text|下面的代码是我在anaconda+python2.7下加上一个包名为"pydot-ng“的方法，用来制作一个带有决策规则的PDF文件。我希望它能对你有所帮助。|unstyled|depth|inlineStyleRanges|entityRanges|11g5n|from+sklearn+import+tree

clf+=+tree.DecisionTreeClassifier(max_leaf_nodes=n)
clf_+=+clf.fit(X,+data_y)

feature_names+=+X.columns
class_name+=+clf_.classes_.astype(int).astype(str)

def+output_pdf(clf_,+name):
++++from+sklearn+import+tree
++++from+sklearn.externals.six+import+StringIO
++++import+pydot_ng+as+pydot
++++dot_data+=+StringIO()
++++tree.export_graphviz(clf_,+out_file=dot_data,
+++++++++++++++++++++++++feature_names=feature_names,
+++++++++++++++++++++++++class_names=class_name,
+++++++++++++++++++++++++filled=True,+rounded=True,
+++++++++++++++++++++++++special_characters=True,
++++++++++++++++++++++++++node_ids=1,)
++++graph+=+pydot.graph_from_dot_data(dot_data.getvalue())
++++graph.write_pdf("%25s.pdf"%25name)

output_pdf(clf_,+name='filename%25s'%25n)|code-block|syntax|javascript|f3tas|a+tree+graphy+show+here|offset|length|style|UNDERLINE^0|0|0|0|N|0|N|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|T|G|@]|H|@]|6|$]]|$A|I|C|J|2|K|F|U|G|@]|H|@]|6|$L|M]]|$A|N|C|O|2|E|F|V|G|@$P|W|Q|X|R|S]]|H|@$P|Y|Q|Z|A|10]]|6|$]]]]

Codes below is my approach under anaconda python 2.7 plus a package name "pydot-ng" to making a PDF file with decision rules. I hope it is helpful.

<pre><code>from sklearn import tree

clf = tree.DecisionTreeClassifier(max_leaf_nodes=n)
clf_ = clf.fit(X, data_y)

feature_names = X.columns
class_name = clf_.classes_.astype(int).astype(str)

def output_pdf(clf_, name):
 from sklearn import tree
 from sklearn.externals.six import StringIO
 import pydot_ng as pydot
 dot_data = StringIO()
 tree.export_graphviz(clf_, out_file=dot_data,
 feature_names=feature_names,
 class_names=class_name,
 filled=True, rounded=True,
 special_characters=True,
 node_ids=1,)
 graph = pydot.graph_from_dot_data(dot_data.getvalue())
 graph.write_pdf("%s.pdf"%name)

output_pdf(clf_, name='filename%s'%n)
</code></pre>

<a href="http://i.stack.imgur.com/OqHfU.png" rel="nofollow">a tree graphy show here</a>

entityMap|blocks|key|99bgt|text|只是因为每个人都很乐于助人，所以我将对Zelazny7和Daniele的漂亮解决方案进行修改。这是针对python+2.7的，带有标签以使其更具可读性：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|e3532|def+get_code(tree,+feature_names,+tabdepth=0):
++++left++++++=+tree.tree_.children_left
++++right+++++=+tree.tree_.children_right
++++threshold+=+tree.tree_.threshold
++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]
++++value+=+tree.tree_.value

++++def+recurse(left,+right,+threshold,+features,+node,+tabdepth=0):
++++++++++++if+(threshold[node]+!=+-2):
++++++++++++++++++++print+'\t'+*+tabdepth,
++++++++++++++++++++print+"if+(+"+%2B+features[node]+%2B+"+<=+"+%2B+str(threshold[node])+%2B+"+)+{"
++++++++++++++++++++if+left[node]+!=+-1:
++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,left[node],+tabdepth%2B1)
++++++++++++++++++++print+'\t'+*+tabdepth,
++++++++++++++++++++print+"}+else+{"
++++++++++++++++++++if+right[node]+!=+-1:
++++++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,right[node],+tabdepth%2B1)
++++++++++++++++++++print+'\t'+*+tabdepth,
++++++++++++++++++++print+"}"
++++++++++++else:
++++++++++++++++++++print+'\t'+*+tabdepth,
++++++++++++++++++++print+"return+"+%2B+str(value[node])

++++recurse(left,+right,+threshold,+features,+0)|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Just because everyone was so helpful I'll just add a modification to Zelazny7 and Daniele's beautiful solutions. This one is for python 2.7, with tabs to make it more readable:

<pre><code>def get_code(tree, feature_names, tabdepth=0):
 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 features = [feature_names[i] for i in tree.tree_.feature]
 value = tree.tree_.value

 def recurse(left, right, threshold, features, node, tabdepth=0):
 if (threshold[node] != -2):
 print '\t' * tabdepth,
 print "if ( " + features[node] + " &lt;= " + str(threshold[node]) + " ) {"
 if left[node] != -1:
 recurse (left, right, threshold, features,left[node], tabdepth+1)
 print '\t' * tabdepth,
 print "} else {"
 if right[node] != -1:
 recurse (left, right, threshold, features,right[node], tabdepth+1)
 print '\t' * tabdepth,
 print "}"
 else:
 print '\t' * tabdepth,
 print "return " + str(value[node])

 recurse(left, right, threshold, features, 0)
</code></pre>

entityMap|blocks|key|af3a5|text|我认为这个答案比这里的其他答案更正确：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|b7clc|from+sklearn.tree+import+_tree

def+tree_to_code(tree,+feature_names):
++++tree_+=+tree.tree_
++++feature_name+=+[
++++++++feature_names[i]+if+i+!=+_tree.TREE_UNDEFINED+else+"undefined!"
++++++++for+i+in+tree_.feature
++++]
++++print+"def+tree({}):".format(",+".join(feature_names))

++++def+recurse(node,+depth):
++++++++indent+=+"++"+*+depth
++++++++if+tree_.feature[node]+!=+_tree.TREE_UNDEFINED:
++++++++++++name+=+feature_name[node]
++++++++++++threshold+=+tree_.threshold[node]
++++++++++++print+"{}if+{}+<=+{}:".format(indent,+name,+threshold)
++++++++++++recurse(tree_.children_left[node],+depth+%2B+1)
++++++++++++print+"{}else:++#+if+{}+>+{}".format(indent,+name,+threshold)
++++++++++++recurse(tree_.children_right[node],+depth+%2B+1)
++++++++else:
++++++++++++print+"{}return+{}".format(indent,+tree_.value[node])

++++recurse(0,+1)|code-block|syntax|javascript|2aje6|这将打印出一个有效的Python函数。下面是一个树的示例输出，它试图返回其输入，一个介于0和10之间的数字。|29cf7|def+tree(f0):
++if+f0+<=+6.0:
++++if+f0+<=+1.5:
++++++return+[[+0.]]
++++else:++#+if+f0+>+1.5
++++++if+f0+<=+4.5:
++++++++if+f0+<=+3.5:
++++++++++return+[[+3.]]
++++++++else:++#+if+f0+>+3.5
++++++++++return+[[+4.]]
++++++else:++#+if+f0+>+4.5
++++++++return+[[+5.]]
++else:++#+if+f0+>+6.0
++++if+f0+<=+8.5:
++++++if+f0+<=+7.5:
++++++++return+[[+7.]]
++++++else:++#+if+f0+>+7.5
++++++++return+[[+8.]]
++++else:++#+if+f0+>+8.5
++++++return+[[+9.]]|3ufb7|以下是我在其他答案中看到的一些绊脚石：|3hgh0|使用tree_.threshold+==+-2判断一个节点是否是叶子并不是一个好主意。如果它是一个阈值为-2的实际决策节点呢？相反，您应该查看tree.feature或者tree.children_*..。|offset|length|style|CODE|bp34t|这条线features+=+[feature_names[i]+for+i+in+tree_.feature]|e7ro2|在我的sklearn版本中崩溃，因为tree.tree_.feature|428ck|是-2+(专用于叶节点)。|4bju5|在递归函数中不需要有多个if语句，只需要一个就可以了。^0|0|0|0|0|0|2|L|1Z|C|2D|F|0|3|1G|0|I|I|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|11|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|12|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|13|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|14|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|15|9|@]|A|@]|B|$]]|$2|N|4|O|6|7|8|16|9|@$P|17|Q|18|R|S]|$P|19|Q|1A|R|S]|$P|1B|Q|1C|R|S]]|A|@]|B|$]]|$2|T|4|U|6|7|8|1D|9|@$P|1E|Q|1F|R|S]]|A|@]|B|$]]|$2|V|4|W|6|7|8|1G|9|@$P|1H|Q|1I|R|S]]|A|@]|B|$]]|$2|X|4|Y|6|7|8|1J|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|1K|9|@]|A|@]|B|$]]]]

I believe that this answer is more correct than the other answers here:

<pre><code>from sklearn.tree import _tree

def tree_to_code(tree, feature_names):
 tree_ = tree.tree_
 feature_name = [
 feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
 for i in tree_.feature
 ]
 print "def tree({}):".format(", ".join(feature_names))

 def recurse(node, depth):
 indent = " " * depth
 if tree_.feature[node] != _tree.TREE_UNDEFINED:
 name = feature_name[node]
 threshold = tree_.threshold[node]
 print "{}if {} &lt;= {}:".format(indent, name, threshold)
 recurse(tree_.children_left[node], depth + 1)
 print "{}else: # if {} &gt; {}".format(indent, name, threshold)
 recurse(tree_.children_right[node], depth + 1)
 else:
 print "{}return {}".format(indent, tree_.value[node])

 recurse(0, 1)
</code></pre>

This prints out a valid Python function. Here's an example output for a tree that is trying to return its input, a number between 0 and 10.

<pre><code>def tree(f0):
 if f0 &lt;= 6.0:
 if f0 &lt;= 1.5:
 return [[ 0.]]
 else: # if f0 &gt; 1.5
 if f0 &lt;= 4.5:
 if f0 &lt;= 3.5:
 return [[ 3.]]
 else: # if f0 &gt; 3.5
 return [[ 4.]]
 else: # if f0 &gt; 4.5
 return [[ 5.]]
 else: # if f0 &gt; 6.0
 if f0 &lt;= 8.5:
 if f0 &lt;= 7.5:
 return [[ 7.]]
 else: # if f0 &gt; 7.5
 return [[ 8.]]
 else: # if f0 &gt; 8.5
 return [[ 9.]]
</code></pre>

Here are some stumbling blocks that I see in other answers:

<ol>
<li>Using <code>tree_.threshold == -2</code> to decide whether a node is a leaf isn't a good idea. What if it's a real decision node with a threshold of -2? Instead, you should look at <code>tree.feature</code> or <code>tree.children_*</code>.</li>
<li>The line <code>features = [feature_names[i] for i in tree_.feature]</code> crashes with my version of sklearn, because some values of <code>tree.tree_.feature</code> are -2 (specifically for leaf nodes).</li>
<li>There is no need to have multiple if statements in the recursive function, just one is fine.</li>
</ol>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://scikit-learn.org/stable/whats_new.html#version-0-18|1|http://scikit-learn.org/stable/auto_examples/tree/plot_unveil_tree_structure.html|2|https://github.com/scikit-learn/scikit-learn/pull/8653|3|https://github.com/scikit-learn/scikit-learn/pull/10951|blocks|key|d3rqf|text|有一个新的DecisionTreeClassifier方法，decision_path|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|97dp4|，在0.18.0释放。开发人员提供了广泛的(有良好文档记录的)|a3fnm|walkthrough.|UNDERLINE|4vu91|演练中打印树结构的第一部分代码似乎没有问题。但是，我修改了第二部分中的代码以询问一个样本。我的更改用#+<--|1ecmp|编辑标记的更改#+<--在pull请求中指出错误后，已在演练链接中更新了以下代码中的#8653+和+#10951..。现在跟上就容易多了。|vqk6|sample_id+=+0
node_index+=+node_indicator.indices[node_indicator.indptr[sample_id]:
++++++++++++++++++++++++++++++++++++node_indicator.indptr[sample_id+%2B+1]]

print('Rules+used+to+predict+sample+%25s:+'+%25+sample_id)
for+node_id+in+node_index:

++++if+leave_id[sample_id]+==+node_id:++#+<--+changed+!=+to+==
++++++++#continue+#+<--+comment+out
++++++++print("leaf+node+{}+reached,+no+decision+here".format(leave_id[sample_id]))+#+<--

++++else:+#+<+--+added+else+to+iterate+through+decision+nodes
++++++++if+(X_test[sample_id,+feature[node_id]]+<=+threshold[node_id]):
++++++++++++threshold_sign+=+"<="
++++++++else:
++++++++++++threshold_sign+=+">"

++++++++print("decision+id+node+%25s+:+(X[%25s,+%25s]+(=+%25s)+%25s+%25s)"
++++++++++++++%25+(node_id,
+++++++++++++++++sample_id,
+++++++++++++++++feature[node_id],
+++++++++++++++++X_test[sample_id,+feature[node_id]],+#+<--+changed+i+to+sample_id
+++++++++++++++++threshold_sign,
+++++++++++++++++threshold[node_id]))

Rules+used+to+predict+sample+0:+
decision+id+node+0+:+(X[0,+3]+(=+2.4)+>+0.800000011921)
decision+id+node+2+:+(X[0,+2]+(=+5.1)+>+4.94999980927)
leaf+node+4+reached,+no+decision+here|code-block|syntax|javascript|16mof|更改sample_id查看其他样本的决策路径。我没有向开发人员询问这些更改，只是在完成示例时看起来更直观。^0|5|M|0|2|6|0|0|0|B|0|B|1|0|1E|5|0|9|3|16|5|2|1E|6|3|0|0|2|9^^$0|$1|$2|3|4|5|6|$7|8]]|9|$2|3|4|5|6|$7|A]]|B|$2|3|4|5|6|$7|C]]|D|$2|3|4|5|6|$7|E]]]|F|@$G|H|I|J|2|K|L|18|M|@$N|19|O|1A|P|Q]]|R|@]|6|$]]|$G|S|I|T|2|K|L|1B|M|@]|R|@$N|1C|O|1D|G|1E]]|6|$]]|$G|U|I|V|2|K|L|1F|M|@$N|1G|O|1H|P|W]]|R|@$N|1I|O|1J|G|1K]]|6|$]]|$G|X|I|Y|2|K|L|1L|M|@$N|1M|O|1N|P|Q]]|R|@]|6|$]]|$G|Z|I|10|2|K|L|1O|M|@$N|1P|O|1Q|P|Q]]|R|@$N|1R|O|1S|G|1T]|$N|1U|O|1V|G|1W]]|6|$]]|$G|11|I|12|2|13|L|1X|M|@]|R|@]|6|$14|15]]|$G|16|I|17|2|K|L|1Y|M|@$N|1Z|O|20|P|Q]]|R|@]|6|$]]]]

There is a new <a href="http://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html#sklearn.tree.DecisionTreeClassifier" rel="noreferrer"><code>DecisionTreeClassifier</code></a> method, <code>decision_path</code>, in the <a href="http://scikit-learn.org/stable/whats_new.html#version-0-18" rel="noreferrer">0.18.0</a> release. The developers provide an extensive (well-documented) <a href="http://scikit-learn.org/stable/auto_examples/tree/plot_unveil_tree_structure.html" rel="noreferrer">walkthrough</a>.

The first section of code in the walkthrough that prints the tree structure seems to be OK. However, I modified the code in the second section to interrogate one sample. My changes denoted with <code># &lt;--</code>

Edit The changes marked by <code># &lt;--</code> in the code below have since been updated in walkthrough link after the errors were pointed out in pull requests <a href="https://github.com/scikit-learn/scikit-learn/pull/8653" rel="noreferrer">#8653</a> and <a href="https://github.com/scikit-learn/scikit-learn/pull/10951" rel="noreferrer">#10951</a>. It's much easier to follow along now. 

<pre><code>sample_id = 0
node_index = node_indicator.indices[node_indicator.indptr[sample_id]:
 node_indicator.indptr[sample_id + 1]]

print('Rules used to predict sample %s: ' % sample_id)
for node_id in node_index:

 if leave_id[sample_id] == node_id: # &lt;-- changed != to ==
 #continue # &lt;-- comment out
 print("leaf node {} reached, no decision here".format(leave_id[sample_id])) # &lt;--

 else: # &lt; -- added else to iterate through decision nodes
 if (X_test[sample_id, feature[node_id]] &lt;= threshold[node_id]):
 threshold_sign = "&lt;="
 else:
 threshold_sign = "&gt;"

 print("decision id node %s : (X[%s, %s] (= %s) %s %s)"
 % (node_id,
 sample_id,
 feature[node_id],
 X_test[sample_id, feature[node_id]], # &lt;-- changed i to sample_id
 threshold_sign,
 threshold[node_id]))

Rules used to predict sample 0: 
decision id node 0 : (X[0, 3] (= 2.4) &gt; 0.800000011921)
decision id node 2 : (X[0, 2] (= 5.1) &gt; 4.94999980927)
leaf node 4 reached, no decision here
</code></pre>

Change the <code>sample_id</code> to see the decision paths for other samples. I haven't asked the developers about these changes, just seemed more intuitive when working through the example.

entityMap|blocks|key|72r2j|text|修改了Zelazny7的代码，以便从决策树中获取SQL。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|ddvl8|#+SQL+from+decision+tree

def+get_lineage(tree,+feature_names):
+++++left++++++=+tree.tree_.children_left
+++++right+++++=+tree.tree_.children_right
+++++threshold+=+tree.tree_.threshold
+++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]
+++++le='<='+++++++++++++++
+++++g+='>'
+++++#+get+ids+of+child+nodes
+++++idx+=+np.argwhere(left+==+-1)[:,0]+++++

+++++def+recurse(left,+right,+child,+lineage=None):++++++++++
++++++++++if+lineage+is+None:
+++++++++++++++lineage+=+[child]
++++++++++if+child+in+left:
+++++++++++++++parent+=+np.where(left+==+child)[0].item()
+++++++++++++++split+=+'l'
++++++++++else:
+++++++++++++++parent+=+np.where(right+==+child)[0].item()
+++++++++++++++split+=+'r'
++++++++++lineage.append((parent,+split,+threshold[parent],+features[parent]))
++++++++++if+parent+==+0:
+++++++++++++++lineage.reverse()
+++++++++++++++return+lineage
++++++++++else:
+++++++++++++++return+recurse(left,+right,+parent,+lineage)
+++++print+'case+'
+++++for+j,child+in+enumerate(idx):
++++++++clause='+when+'
++++++++for+node+in+recurse(left,+right,+child):
++++++++++++if+len(str(node))<3:
++++++++++++++++continue
++++++++++++i=node
++++++++++++if+i[1]=='l':++sign=le+
++++++++++++else:+sign=g
++++++++++++clause=clause%2Bi[3]%2Bsign%2Bstr(i[2])%2B'+and+'
++++++++clause=clause[:-4]%2B'+then+'%2Bstr(j)
++++++++print+clause
+++++print+'else+99+end+as+clusters'|code-block|syntax|javascript^0|0^^$0|$]|1|@$2|3|4|5|6|7|8|H|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|I|9|@]|A|@]|B|$F|G]]]]

Modified Zelazny7's code to fetch SQL from the decision tree.

<pre><code># SQL from decision tree

def get_lineage(tree, feature_names):
 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 features = [feature_names[i] for i in tree.tree_.feature]
 le='&lt;=' 
 g ='&gt;'
 # get ids of child nodes
 idx = np.argwhere(left == -1)[:,0] 

 def recurse(left, right, child, lineage=None): 
 if lineage is None:
 lineage = [child]
 if child in left:
 parent = np.where(left == child)[0].item()
 split = 'l'
 else:
 parent = np.where(right == child)[0].item()
 split = 'r'
 lineage.append((parent, split, threshold[parent], features[parent]))
 if parent == 0:
 lineage.reverse()
 return lineage
 else:
 return recurse(left, right, parent, lineage)
 print 'case '
 for j,child in enumerate(idx):
 clause=' when '
 for node in recurse(left, right, child):
 if len(str(node))&lt;3:
 continue
 i=node
 if i[1]=='l': sign=le 
 else: sign=g
 clause=clause+i[3]+sign+str(i[2])+' and '
 clause=clause[:-4]+' then '+str(j)
 print clause
 print 'else 99 end as clusters'
</code></pre>

entityMap|blocks|key|8i2kd|text|这建立在@paulkernfeld的答案上。如果你有一个带有特征的数据帧X和一个带有共振的目标数据帧y，你想知道哪个y值在哪个节点结束(并相应地绘制它)，你可以执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|8728v|def+tree_to_code(tree,+feature_names):
++++++++from+sklearn.tree+import+_tree
++++++++codelines+=+[]
++++++++codelines.append('def+get_cat(X_tmp):\n')
++++++++codelines.append('+++catout+=+[]\n')
++++++++codelines.append('+++for+codelines+in+range(0,X_tmp.shape[0]):\n')
++++++++codelines.append('++++++Xin+=+X_tmp.iloc[codelines]\n')
++++++++tree_+=+tree.tree_
++++++++feature_name+=+[
++++++++++++feature_names[i]+if+i+!=+_tree.TREE_UNDEFINED+else+"undefined!"
++++++++++++for+i+in+tree_.feature
++++++++]
++++++++#print+"def+tree({}):".format(",+".join(feature_names))

++++++++def+recurse(node,+depth):
++++++++++++indent+=+"++++++"+*+depth
++++++++++++if+tree_.feature[node]+!=+_tree.TREE_UNDEFINED:
++++++++++++++++name+=+feature_name[node]
++++++++++++++++threshold+=+tree_.threshold[node]
++++++++++++++++codelines.append+('{}if+Xin["{}"]+<=+{}:\n'.format(indent,+name,+threshold))
++++++++++++++++recurse(tree_.children_left[node],+depth+%2B+1)
++++++++++++++++codelines.append(+'{}else:++#+if+Xin["{}"]+>+{}\n'.format(indent,+name,+threshold))
++++++++++++++++recurse(tree_.children_right[node],+depth+%2B+1)
++++++++++++else:
++++++++++++++++codelines.append(+'{}mycat+=+{}\n'.format(indent,+node))

++++++++recurse(0,+1)
++++++++codelines.append('++++++catout.append(mycat)\n')
++++++++codelines.append('+++return+pd.DataFrame(catout,index=X_tmp.index,columns=["category"])\n')
++++++++codelines.append('node_ids+=+get_cat(X)\n')
++++++++return+codelines
++++mycode+=+tree_to_code(clf,X.columns.values)

++++#+now+execute+the+function+and+obtain+the+dataframe+with+all+nodes
++++exec(''.join(mycode))
++++node_ids+=+[int(x[0])+for+x+in+node_ids.values]
++++node_ids2+=+pd.DataFrame(node_ids)

++++print('make+plot')
++++import+matplotlib.cm+as+cm
++++colors+=+cm.rainbow(np.linspace(0,+1,+1%2Bmax(+list(set(node_ids)))))
++++#plt.figure(figsize=cm2inch(24,+21))
++++for+i+in+list(set(node_ids)):
++++++++plt.plot(y[node_ids2.values==i],'o',color=colors[i],+label=str(i))++
++++mytitle+=+['y+colored+by+node']
++++plt.title(mytitle+,fontsize=14)
++++plt.xlabel('my+xlabel')
++++plt.ylabel(tagname)
++++plt.xticks(rotation=70)+++++++
++++plt.legend(loc='upper+center',+bbox_to_anchor=(0.5,+1.00),+shadow=True,+ncol=9)
++++plt.tight_layout()
++++plt.show()
++++plt.close|code-block|syntax|javascript|ebaak|不是最优雅的版本，但它可以完成工作...^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|K|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|L|9|@]|A|@]|B|$]]]]

This builds on @paulkernfeld 's answer. If you have a dataframe X with your features and a target dataframe y with your resonses and you you want to get an idea which y value ended in which node (and also ant to plot it accordingly) you can do the following:

<pre><code> def tree_to_code(tree, feature_names):
 from sklearn.tree import _tree
 codelines = []
 codelines.append('def get_cat(X_tmp):\n')
 codelines.append(' catout = []\n')
 codelines.append(' for codelines in range(0,X_tmp.shape[0]):\n')
 codelines.append(' Xin = X_tmp.iloc[codelines]\n')
 tree_ = tree.tree_
 feature_name = [
 feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
 for i in tree_.feature
 ]
 #print "def tree({}):".format(", ".join(feature_names))

 def recurse(node, depth):
 indent = " " * depth
 if tree_.feature[node] != _tree.TREE_UNDEFINED:
 name = feature_name[node]
 threshold = tree_.threshold[node]
 codelines.append ('{}if Xin["{}"] &lt;= {}:\n'.format(indent, name, threshold))
 recurse(tree_.children_left[node], depth + 1)
 codelines.append( '{}else: # if Xin["{}"] &gt; {}\n'.format(indent, name, threshold))
 recurse(tree_.children_right[node], depth + 1)
 else:
 codelines.append( '{}mycat = {}\n'.format(indent, node))

 recurse(0, 1)
 codelines.append(' catout.append(mycat)\n')
 codelines.append(' return pd.DataFrame(catout,index=X_tmp.index,columns=["category"])\n')
 codelines.append('node_ids = get_cat(X)\n')
 return codelines
 mycode = tree_to_code(clf,X.columns.values)

 # now execute the function and obtain the dataframe with all nodes
 exec(''.join(mycode))
 node_ids = [int(x[0]) for x in node_ids.values]
 node_ids2 = pd.DataFrame(node_ids)

 print('make plot')
 import matplotlib.cm as cm
 colors = cm.rainbow(np.linspace(0, 1, 1+max( list(set(node_ids)))))
 #plt.figure(figsize=cm2inch(24, 21))
 for i in list(set(node_ids)):
 plt.plot(y[node_ids2.values==i],'o',color=colors[i], label=str(i)) 
 mytitle = ['y colored by node']
 plt.title(mytitle ,fontsize=14)
 plt.xlabel('my xlabel')
 plt.ylabel(tagname)
 plt.xticks(rotation=70) 
 plt.legend(loc='upper center', bbox_to_anchor=(0.5, 1.00), shadow=True, ncol=9)
 plt.tight_layout()
 plt.show()
 plt.close 
</code></pre>

not the most elegant version but it does the job...

entityMap|blocks|key|a5raq|text|我已经经历过这种情况，但我需要以这种格式编写规则|type|unstyled|depth|inlineStyleRanges|entityRanges|data|fsde7|if+A>0.4+then+if+B<0.2+then+if+C>0.8+then+class='X'|code-block|syntax|javascript|fvtd8|所以我改写了@paulkernfeld的答案(谢谢)，你可以根据自己的需要进行定制|6q90j|def+tree_to_code(tree,+feature_names,+Y):
++++tree_+=+tree.tree_
++++feature_name+=+[
++++++++feature_names[i]+if+i+!=+_tree.TREE_UNDEFINED+else+"undefined!"
++++++++for+i+in+tree_.feature
++++]
++++pathto=dict()

++++global+k
++++k+=+0
++++def+recurse(node,+depth,+parent):
++++++++global+k
++++++++indent+=+"++"+*+depth

++++++++if+tree_.feature[node]+!=+_tree.TREE_UNDEFINED:
++++++++++++name+=+feature_name[node]
++++++++++++threshold+=+tree_.threshold[node]
++++++++++++s=+"{}+<=+{}+".format(+name,+threshold,+node+)
++++++++++++if+node+==+0:
++++++++++++++++pathto[node]=s
++++++++++++else:
++++++++++++++++pathto[node]=pathto[parent]%2B'+&+'+%2Bs

++++++++++++recurse(tree_.children_left[node],+depth+%2B+1,+node)
++++++++++++s="{}+>+{}".format(+name,+threshold)
++++++++++++if+node+==+0:
++++++++++++++++pathto[node]=s
++++++++++++else:
++++++++++++++++pathto[node]=pathto[parent]%2B'+&+'+%2Bs
++++++++++++recurse(tree_.children_right[node],+depth+%2B+1,+node)
++++++++else:
++++++++++++k=k%2B1
++++++++++++print(k,')',pathto[parent],+tree_.value[node])
++++recurse(0,+1,+0)^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

I've been going through this, but i needed the rules to be written in this format 

<pre><code>if A&gt;0.4 then if B&lt;0.2 then if C&gt;0.8 then class='X' 
</code></pre>

So I adapted the answer of @paulkernfeld (thanks) that you can customize to your need

<pre><code>def tree_to_code(tree, feature_names, Y):
 tree_ = tree.tree_
 feature_name = [
 feature_names[i] if i != _tree.TREE_UNDEFINED else "undefined!"
 for i in tree_.feature
 ]
 pathto=dict()

 global k
 k = 0
 def recurse(node, depth, parent):
 global k
 indent = " " * depth

 if tree_.feature[node] != _tree.TREE_UNDEFINED:
 name = feature_name[node]
 threshold = tree_.threshold[node]
 s= "{} &lt;= {} ".format( name, threshold, node )
 if node == 0:
 pathto[node]=s
 else:
 pathto[node]=pathto[parent]+' &amp; ' +s

 recurse(tree_.children_left[node], depth + 1, node)
 s="{} &gt; {}".format( name, threshold)
 if node == 0:
 pathto[node]=s
 else:
 pathto[node]=pathto[parent]+' &amp; ' +s
 recurse(tree_.children_right[node], depth + 1, node)
 else:
 k=k+1
 print(k,')',pathto[parent], tree_.value[node])
 recurse(0, 1, 0)
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/scikit-learn/scikit-learn/blob/79bdc8f711d0af225ed6be9fdb708cea9f98a910/sklearn/tree/export.py|blocks|key|8knpl|text|显然很久以前，已经有人决定尝试在官方scikit的树导出功能中添加以下功能(基本上只支持导出_graphviz)|unstyled|depth|inlineStyleRanges|entityRanges|cg40f|def+export_dict(tree,+feature_names=None,+max_depth=None)+:
++++"""Export+a+decision+tree+in+dict+format.|code-block|syntax|javascript|22pb0|以下是他的完整提交：|7hh65|offset|length|1agti|不太确定这条评论发生了什么。但您也可以尝试使用该函数。|91hmv|我认为这需要一个严肃的文档请求给scikit的好心人--学习正确地记录sklearn.tree.TreeAPI，它是底层的树结构，DecisionTreeClassifier作为其属性公开..。|style|CODE^0|0|0|0|0|35|0|0|0|Z|H|1T|M^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|Y|G|@]|H|@]|6|$]]|$A|I|C|J|2|K|F|Z|G|@]|H|@]|6|$L|M]]|$A|N|C|O|2|E|F|10|G|@]|H|@]|6|$]]|$A|P|C|8|2|E|F|11|G|@]|H|@$Q|12|R|13|A|14]]|6|$]]|$A|S|C|T|2|E|F|15|G|@]|H|@]|6|$]]|$A|U|C|V|2|E|F|16|G|@$Q|17|R|18|W|X]|$Q|19|R|1A|W|X]]|H|@]|6|$]]]]

Apparently a long time ago somebody already decided to try to add the following function to the official scikit's tree export functions (which basically only supports export_graphviz)

<pre><code>def export_dict(tree, feature_names=None, max_depth=None) :
 """Export a decision tree in dict format.
</code></pre>

Here is his full commit:

<a href="https://github.com/scikit-learn/scikit-learn/blob/79bdc8f711d0af225ed6be9fdb708cea9f98a910/sklearn/tree/export.py" rel="nofollow noreferrer">https://github.com/scikit-learn/scikit-learn/blob/79bdc8f711d0af225ed6be9fdb708cea9f98a910/sklearn/tree/export.py</a>

Not exactly sure what happened to this comment. But you could also try to use that function.

I think this warrants a serious documentation request to the good people of scikit-learn to properly document the <code>sklearn.tree.Tree</code> API which is the underlying tree structure that <code>DecisionTreeClassifier</code> exposes as its attribute <code>tree_</code>.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://github.com/konstantint/SKompiler|blocks|key|3sapq|text|下面是一种将整个树转换为单个(不一定很容易读懂的)+python表达式的方法。SKompiler库：|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|dc9jo|from+skompiler+import+skompile
skompile(dtree.predict).to('python/code')|code-block|syntax|javascript^0|13|9|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|P|G|@]|H|@$I|Q|J|R|A|S]]|6|$]]|$A|K|C|L|2|M|F|T|G|@]|H|@]|6|$N|O]]]]

Here is a way to translate the whole tree into a single (not necessarily too human-readable) python expression using the <a href="https://github.com/konstantint/SKompiler" rel="nofollow noreferrer">SKompiler</a> library:

<pre><code>from skompiler import skompile
skompile(dtree.predict).to('python/code')
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|http://www.webgraphviz.com/|blocks|key|cp88t|text|只需使用中的函数sklearn.tree像这样|unstyled|depth|inlineStyleRanges|entityRanges|9p9sq|from+sklearn.tree+import+export_graphviz
++++export_graphviz(tree,
++++++++++++++++out_file+=+"tree.dot",
++++++++++++++++feature_names+=+tree.columns)+//or+just+["petal+length",+"petal+width"]|code-block|syntax|javascript|3okc0|，然后在项目文件夹中查找该文件。tree.dot，将所有内容复制并粘贴到此处http://www.webgraphviz.com/并生成您的图表:)|offset|length|style|UNDERLINE^0|0|0|12|R|12|R|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|T|G|@]|H|@]|6|$]]|$A|I|C|J|2|K|F|U|G|@]|H|@]|6|$L|M]]|$A|N|C|O|2|E|F|V|G|@$P|W|Q|X|R|S]]|H|@$P|Y|Q|Z|A|10]]|6|$]]]]

Just use the function from sklearn.tree like this

<pre><code>from sklearn.tree import export_graphviz
 export_graphviz(tree,
 out_file = "tree.dot",
 feature_names = tree.columns) //or just ["petal length", "petal width"]
</code></pre>

And then look in your project folder for the file tree.dot, copy the ALL the content and paste it here <a href="http://www.webgraphviz.com/" rel="nofollow noreferrer">http://www.webgraphviz.com/</a> and generate your graph :)

entityMap|0|type|IMAGE|mutability|IMMUTABLE|data|imageUrl|https://ask.qcloudimg.com/http-save/actteam/b7c6e74f96ab675ec9a1abd2ad1990ad.png|imageAlt|blocks|key|cfmof|text|您还可以通过区分它所属的类，或者甚至通过提到它的输出值，使它更具信息性。|unstyled|depth|inlineStyleRanges|entityRanges|4pnkj|def+print_decision_tree(tree,+feature_names,+offset_unit='++++'):++++
left++++++=+tree.tree_.children_left
right+++++=+tree.tree_.children_right
threshold+=+tree.tree_.threshold
value+=+tree.tree_.value
if+feature_names+is+None:
++++features++=+['f%25d'%25i+for+i+in+tree.tree_.feature]
else:
++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]++++++++

def+recurse(left,+right,+threshold,+features,+node,+depth=0):
++++++++offset+=+offset_unit*depth
++++++++if+(threshold[node]+!=+-2):
++++++++++++++++print(offset%2B"if+(+"+%2B+features[node]+%2B+"+<=+"+%2B+str(threshold[node])+%2B+"+)+{")
++++++++++++++++if+left[node]+!=+-1:
++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,left[node],depth%2B1)
++++++++++++++++print(offset%2B"}+else+{")
++++++++++++++++if+right[node]+!=+-1:
++++++++++++++++++++++++recurse+(left,+right,+threshold,+features,right[node],depth%2B1)
++++++++++++++++print(offset%2B"}")
++++++++else:
++++++++++++++++#print(offset,value[node])+

++++++++++++++++#To+remove+values+from+node
++++++++++++++++temp=str(value[node])
++++++++++++++++mid=len(temp)//2
++++++++++++++++tempx=[]
++++++++++++++++tempy=[]
++++++++++++++++cnt=0
++++++++++++++++for+i+in+temp:
++++++++++++++++++++if+cnt<=mid:
++++++++++++++++++++++++tempx.append(i)
++++++++++++++++++++++++cnt%2B=1
++++++++++++++++++++else:
++++++++++++++++++++++++tempy.append(i)
++++++++++++++++++++++++cnt%2B=1
++++++++++++++++val_yes=[]
++++++++++++++++val_no=[]
++++++++++++++++res=[]
++++++++++++++++for+j+in+tempx:
++++++++++++++++++++if+j=="["+or+j=="]"+or+j=="."+or+j=="+":
++++++++++++++++++++++++res.append(j)
++++++++++++++++++++else:
++++++++++++++++++++++++val_no.append(j)
++++++++++++++++for+j+in+tempy:
++++++++++++++++++++if+j=="["+or+j=="]"+or+j=="."+or+j=="+":
++++++++++++++++++++++++res.append(j)
++++++++++++++++++++else:
++++++++++++++++++++++++val_yes.append(j)
++++++++++++++++val_yes+=+int("".join(map(str,+val_yes)))
++++++++++++++++val_no+=+int("".join(map(str,+val_no)))

++++++++++++++++if+val_yes>val_no:
++++++++++++++++++++print(offset,'\033[1m',"YES")
++++++++++++++++++++print('\033[0m')
++++++++++++++++elif+val_no>val_yes:
++++++++++++++++++++print(offset,'\033[1m',"NO")
++++++++++++++++++++print('\033[0m')
++++++++++++++++else:
++++++++++++++++++++print(offset,'\033[1m',"Tie")
++++++++++++++++++++print('\033[0m')

recurse(left,+right,+threshold,+features,+0,0)|code-block|syntax|javascript|f0o34|​|3l3im|d1jtm|?|atomic|offset|length|dsdk0|at870^0|0|0|0|0|0|1|0|0|0^^$0|$1|$2|3|4|5|6|$7|8|9|-4]]]|A|@$B|C|D|E|2|F|G|Y|H|@]|I|@]|6|$]]|$B|J|D|K|2|L|G|Z|H|@]|I|@]|6|$M|N]]|$B|O|D|P|2|F|G|10|H|@]|I|@]|6|$]]|$B|Q|D|-4|2|F|G|11|H|@]|I|@]|6|$]]|$B|R|D|S|2|T|G|12|H|@]|I|@$U|13|V|14|B|15]]|6|$]]|$B|W|D|-4|2|F|G|16|H|@]|I|@]|6|$]]|$B|X|D|P|2|F|G|17|H|@]|I|@]|6|$]]]]

You can also make it more informative by distinguishing it to which class it belongs or even by mentioning its output value.

<pre><code>def print_decision_tree(tree, feature_names, offset_unit=' '): 
left = tree.tree_.children_left
right = tree.tree_.children_right
threshold = tree.tree_.threshold
value = tree.tree_.value
if feature_names is None:
 features = ['f%d'%i for i in tree.tree_.feature]
else:
 features = [feature_names[i] for i in tree.tree_.feature] 

def recurse(left, right, threshold, features, node, depth=0):
 offset = offset_unit*depth
 if (threshold[node] != -2):
 print(offset+"if ( " + features[node] + " &lt;= " + str(threshold[node]) + " ) {")
 if left[node] != -1:
 recurse (left, right, threshold, features,left[node],depth+1)
 print(offset+"} else {")
 if right[node] != -1:
 recurse (left, right, threshold, features,right[node],depth+1)
 print(offset+"}")
 else:
 #print(offset,value[node]) 

 #To remove values from node
 temp=str(value[node])
 mid=len(temp)//2
 tempx=[]
 tempy=[]
 cnt=0
 for i in temp:
 if cnt&lt;=mid:
 tempx.append(i)
 cnt+=1
 else:
 tempy.append(i)
 cnt+=1
 val_yes=[]
 val_no=[]
 res=[]
 for j in tempx:
 if j=="[" or j=="]" or j=="." or j==" ":
 res.append(j)
 else:
 val_no.append(j)
 for j in tempy:
 if j=="[" or j=="]" or j=="." or j==" ":
 res.append(j)
 else:
 val_yes.append(j)
 val_yes = int("".join(map(str, val_yes)))
 val_no = int("".join(map(str, val_no)))

 if val_yes&gt;val_no:
 print(offset,'\033[1m',"YES")
 print('\033[0m')
 elif val_no&gt;val_yes:
 print(offset,'\033[1m',"NO")
 print('\033[0m')
 else:
 print(offset,'\033[1m',"Tie")
 print('\033[0m')

recurse(left, right, threshold, features, 0,0)
</code></pre>

<a href="https://i.stack.imgur.com/rkMWK.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/rkMWK.png" alt="enter image description here"></a>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://scikit-learn.org/stable/modules/generated/sklearn.tree.export_text.html|blocks|key|dhj8j|text|Scikit+learn介绍了一种非常好用的新方法，称为export_text在版本0.21+(2019年5月)中，从树中提取规则。|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|24jo5|Documentation+here..。不再需要创建自定义函数。|8hif0|一旦你建立了你的模型，你只需要两行代码。首先，导入export_text|5dsc5|from+sklearn.tree+import+export_text|code-block|syntax|javascript|2i891|其次，创建一个包含规则的对象。若要使规则看起来更具可读性，请使用feature_names参数并传递功能名称的列表。例如，如果您的模型被称为model并且您的要素在名为的数据帧中命名X_train，您可以创建一个名为tree_rules|1f86c|tree_rules+=+export_text(model,+feature_names=list(X_train.columns))|20l73|然后只需打印或保存tree_rules..。您的输出将如下所示：|a4bi3|%7C---+Age+<=+0.63
%7C+++%7C---+EstimatedSalary+<=+0.61
%7C+++%7C+++%7C---+Age+<=+-0.16
%7C+++%7C+++%7C+++%7C---+class:+0
%7C+++%7C+++%7C---+Age+>++-0.16
%7C+++%7C+++%7C+++%7C---+EstimatedSalary+<=+-0.06
%7C+++%7C+++%7C+++%7C+++%7C---+class:+0
%7C+++%7C+++%7C+++%7C---+EstimatedSalary+>++-0.06
%7C+++%7C+++%7C+++%7C+++%7C---+EstimatedSalary+<=+0.40
%7C+++%7C+++%7C+++%7C+++%7C+++%7C---+EstimatedSalary+<=+0.03
%7C+++%7C+++%7C+++%7C+++%7C+++%7C+++%7C---+class:+1^0|S|B|0|0|I|0|0|P|B|0|0|W|D|1Y|5|2J|7|30|A|0|0|9|A|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|13|G|@$H|14|I|15|J|K]]|L|@]|6|$]]|$A|M|C|N|2|E|F|16|G|@]|L|@$H|17|I|18|A|19]]|6|$]]|$A|O|C|P|2|E|F|1A|G|@$H|1B|I|1C|J|K]]|L|@]|6|$]]|$A|Q|C|R|2|S|F|1D|G|@]|L|@]|6|$T|U]]|$A|V|C|W|2|E|F|1E|G|@$H|1F|I|1G|J|K]|$H|1H|I|1I|J|K]|$H|1J|I|1K|J|K]|$H|1L|I|1M|J|K]]|L|@]|6|$]]|$A|X|C|Y|2|S|F|1N|G|@]|L|@]|6|$T|U]]|$A|Z|C|10|2|E|F|1O|G|@$H|1P|I|1Q|J|K]]|L|@]|6|$]]|$A|11|C|12|2|S|F|1R|G|@]|L|@]|6|$T|U]]]]

Scikit learn introduced a delicious new method called <code>export_text</code> in version 0.21 (May 2019) to extract the rules from a tree. <a href="https://scikit-learn.org/stable/modules/generated/sklearn.tree.export_text.html" rel="noreferrer">Documentation here</a>. It's no longer necessary to create a custom function.
Once you've fit your model, you just need two lines of code. First, import <code>export_text</code>:
<pre><code>from sklearn.tree import export_text
</code></pre>
Second, create an object that will contain your rules. To make the rules look more readable, use the <code>feature_names</code> argument and pass a list of your feature names. For example, if your model is called <code>model</code> and your features are named in a dataframe called <code>X_train</code>, you could create an object called <code>tree_rules</code>:
<pre><code>tree_rules = export_text(model, feature_names=list(X_train.columns))
</code></pre>
Then just print or save <code>tree_rules</code>. Your output will look like this:
<pre><code>|--- Age &lt;= 0.63
| |--- EstimatedSalary &lt;= 0.61
| | |--- Age &lt;= -0.16
| | | |--- class: 0
| | |--- Age &gt; -0.16
| | | |--- EstimatedSalary &lt;= -0.06
| | | | |--- class: 0
| | | |--- EstimatedSalary &gt; -0.06
| | | | |--- EstimatedSalary &lt;= 0.40
| | | | | |--- EstimatedSalary &lt;= 0.03
| | | | | | |--- class: 1
</code></pre>

entityMap|blocks|key|6qpun|text|下面是我提取决策规则的方法，这种形式可以直接在sql中使用，因此可以按节点对数据进行分组。(基于之前海报的方法。)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d3c8t|结果将是后续的CASE可以复制到sql语句的子句，例如。|offset|length|style|CODE|18rs3|SELECT+COALESCE(*CASE+WHEN++THEN+>+*,+>+*CASE+WHEN+++THEN+*,+>+....)NodeName,*+>+FROM+|52hvp|​|743cf|import+numpy+as+np

import+pickle
feature_names=.............
features++=+[feature_names[i]+for+i+in+range(len(feature_names))]
clf=+pickle.loads(trained_model)
impurity=clf.tree_.impurity
importances+=+clf.feature_importances_
SqlOut=""

#global+Conts
global+ContsNode
global+Path
#Conts=[]#
ContsNode=[]
Path=[]
global+Results
Results=[]

def+print_decision_tree(tree,+feature_names,+offset_unit=''++++''):++++
++++left++++++=+tree.tree_.children_left
++++right+++++=+tree.tree_.children_right
++++threshold+=+tree.tree_.threshold
++++value+=+tree.tree_.value

++++if+feature_names+is+None:
++++++++features++=+[''f%25d''%25i+for+i+in+tree.tree_.feature]
++++else:
++++++++features++=+[feature_names[i]+for+i+in+tree.tree_.feature]++++++++

++++def+recurse(left,+right,+threshold,+features,+node,+depth=0,ParentNode=0,IsElse=0):
++++++++global+Conts
++++++++global+ContsNode
++++++++global+Path
++++++++global+Results
++++++++global+LeftParents
++++++++LeftParents=[]
++++++++global+RightParents
++++++++RightParents=[]
++++++++for+i+in+range(len(left)):+#+This+is+just+to+tell+you+how+to+create+a+list.
++++++++++++LeftParents.append(-1)
++++++++++++RightParents.append(-1)
++++++++++++ContsNode.append("")
++++++++++++Path.append("")


++++++++for+i+in+range(len(left)):+#+i+is+node
++++++++++++if+(left[i]==-1+and+right[i]==-1):++++++
++++++++++++++++if+LeftParents[i]>=0:
++++++++++++++++++++if+Path[LeftParents[i]]>"+":
++++++++++++++++++++++++Path[i]=Path[LeftParents[i]]%2B"+AND+"+%2BContsNode[LeftParents[i]]+++++++++++++++++++++++++++++++++
++++++++++++++++++++else:
++++++++++++++++++++++++Path[i]=ContsNode[LeftParents[i]]+++++++++++++++++++++++++++++++++++
++++++++++++++++if+RightParents[i]>=0:
++++++++++++++++++++if+Path[RightParents[i]]>"+":
++++++++++++++++++++++++Path[i]=Path[RightParents[i]]%2B"+AND+not+"+%2BContsNode[RightParents[i]]+++++++++++++++++++++++++++++++++++
++++++++++++++++++++else:
++++++++++++++++++++++++Path[i]="+not+"+%2BContsNode[RightParents[i]]+++++++++++++++++++++
++++++++++++++++Results.append("+case+when++"+%2BPath[i]%2B"++then+''"+%2B"{:4d}".format(i)%2B+"+"%2B"{:2.2f}".format(impurity[i])%2B"+"%2BPath[i][0:180]%2B"''")

++++++++++++else:+++++++
++++++++++++++++if+LeftParents[i]>=0:
++++++++++++++++++++if+Path[LeftParents[i]]>"+":
++++++++++++++++++++++++Path[i]=Path[LeftParents[i]]%2B"+AND+"+%2BContsNode[LeftParents[i]]+++++++++++++++++++++++++++++++++
++++++++++++++++++++else:
++++++++++++++++++++++++Path[i]=ContsNode[LeftParents[i]]+++++++++++++++++++++++++++++++++++
++++++++++++++++if+RightParents[i]>=0:
++++++++++++++++++++if+Path[RightParents[i]]>"+":
++++++++++++++++++++++++Path[i]=Path[RightParents[i]]%2B"+AND+not+"+%2BContsNode[RightParents[i]]+++++++++++++++++++++++++++++++++++
++++++++++++++++++++else:
++++++++++++++++++++++++Path[i]="+not+"%2BContsNode[RightParents[i]]++++++++++++++++++++++
++++++++++++++++if+(left[i]!=-1):
++++++++++++++++++++LeftParents[left[i]]=i
++++++++++++++++if+(right[i]!=-1):
++++++++++++++++++++RightParents[right[i]]=i
++++++++++++++++ContsNode[i]=+++"(+"%2B+features[i]+%2B+"+<=+"+%2B+str(threshold[i])+++%2B+"+)+"

++++recurse(left,+right,+threshold,+features,+0,0,0,0)
print_decision_tree(clf,features)
SqlOut=""
for+i+in+range(len(Results)):+
++++SqlOut=SqlOut%2BResults[i]%2B+"+end,"%2Bchr(13)%2Bchr(10)|code-block|syntax|javascript^0|0|7|4|0|0|2E|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|R|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|S|9|@$E|T|F|U|G|H]]|A|@]|B|$]]|$2|I|4|J|6|7|8|V|9|@$E|W|F|X|G|H]]|A|@]|B|$]]|$2|K|4|L|6|7|8|Y|9|@]|A|@]|B|$]]|$2|M|4|N|6|O|8|Z|9|@]|A|@]|B|$P|Q]]]]

Here is my approach to extract the decision rules in a form that can be used in directly in sql, so the data can be grouped by node. (Based on the approaches of previous posters.) 

The result will be subsequent <code>CASE</code> clauses that can be copied to an sql statement, ex.

<code>SELECT COALESCE(*CASE WHEN &lt;conditions&gt; THEN &gt; &lt;NodeA&gt;*, &gt; *CASE WHEN
 &lt;conditions&gt; THEN &lt;NodeB&gt;*, &gt; ....)NodeName,* &gt; FROM &lt;table or view&gt;</code>

<hr>

<pre><code>import numpy as np

import pickle
feature_names=.............
features = [feature_names[i] for i in range(len(feature_names))]
clf= pickle.loads(trained_model)
impurity=clf.tree_.impurity
importances = clf.feature_importances_
SqlOut=""

#global Conts
global ContsNode
global Path
#Conts=[]#
ContsNode=[]
Path=[]
global Results
Results=[]

def print_decision_tree(tree, feature_names, offset_unit='' ''): 
 left = tree.tree_.children_left
 right = tree.tree_.children_right
 threshold = tree.tree_.threshold
 value = tree.tree_.value

 if feature_names is None:
 features = [''f%d''%i for i in tree.tree_.feature]
 else:
 features = [feature_names[i] for i in tree.tree_.feature] 

 def recurse(left, right, threshold, features, node, depth=0,ParentNode=0,IsElse=0):
 global Conts
 global ContsNode
 global Path
 global Results
 global LeftParents
 LeftParents=[]
 global RightParents
 RightParents=[]
 for i in range(len(left)): # This is just to tell you how to create a list.
 LeftParents.append(-1)
 RightParents.append(-1)
 ContsNode.append("")
 Path.append("")


 for i in range(len(left)): # i is node
 if (left[i]==-1 and right[i]==-1): 
 if LeftParents[i]&gt;=0:
 if Path[LeftParents[i]]&gt;" ":
 Path[i]=Path[LeftParents[i]]+" AND " +ContsNode[LeftParents[i]] 
 else:
 Path[i]=ContsNode[LeftParents[i]] 
 if RightParents[i]&gt;=0:
 if Path[RightParents[i]]&gt;" ":
 Path[i]=Path[RightParents[i]]+" AND not " +ContsNode[RightParents[i]] 
 else:
 Path[i]=" not " +ContsNode[RightParents[i]] 
 Results.append(" case when " +Path[i]+" then ''" +"{:4d}".format(i)+ " "+"{:2.2f}".format(impurity[i])+" "+Path[i][0:180]+"''")

 else: 
 if LeftParents[i]&gt;=0:
 if Path[LeftParents[i]]&gt;" ":
 Path[i]=Path[LeftParents[i]]+" AND " +ContsNode[LeftParents[i]] 
 else:
 Path[i]=ContsNode[LeftParents[i]] 
 if RightParents[i]&gt;=0:
 if Path[RightParents[i]]&gt;" ":
 Path[i]=Path[RightParents[i]]+" AND not " +ContsNode[RightParents[i]] 
 else:
 Path[i]=" not "+ContsNode[RightParents[i]] 
 if (left[i]!=-1):
 LeftParents[left[i]]=i
 if (right[i]!=-1):
 RightParents[right[i]]=i
 ContsNode[i]= "( "+ features[i] + " &lt;= " + str(threshold[i]) + " ) "

 recurse(left, right, threshold, features, 0,0,0,0)
print_decision_tree(clf,features)
SqlOut=""
for i in range(len(Results)): 
 SqlOut=SqlOut+Results[i]+ " end,"+chr(13)+chr(10)
</code></pre>

entityMap|blocks|key|etp0l|text|现在可以使用export了_文本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|dn3l8|from+sklearn.tree+import+export_text

r+=+export_text(loan_tree,+feature_names=(list(X_train.columns)))
print(r)|code-block|syntax|javascript|bjre6|中的完整示例sklearn|cvvh|from+sklearn.datasets+import+load_iris
from+sklearn.tree+import+DecisionTreeClassifier
from+sklearn.tree+import+export_text
iris+=+load_iris()
X+=+iris['data']
y+=+iris['target']
decision_tree+=+DecisionTreeClassifier(random_state=0,+max_depth=2)
decision_tree+=+decision_tree.fit(X,+y)
r+=+export_text(decision_tree,+feature_names=iris['feature_names'])
print(r)^0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|L|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|M|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|N|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|O|9|@]|A|@]|B|$F|G]]]]

Now you can use export_text.

<pre><code>from sklearn.tree import export_text

r = export_text(loan_tree, feature_names=(list(X_train.columns)))
print(r)
</code></pre>

A complete example from [sklearn][1]

<pre><code>from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.tree import export_text
iris = load_iris()
X = iris['data']
y = iris['target']
decision_tree = DecisionTreeClassifier(random_state=0, max_depth=2)
decision_tree = decision_tree.fit(X, y)
r = export_text(decision_tree, feature_names=iris['feature_names'])
print(r)
</code></pre>

entityMap|blocks|key|b69rp|text|感谢@paulkerfeld的精彩解决方案。在他的解决方案之上，对于那些想要拥有树的序列化版本的人，只需使用tree.threshold|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|cd5k|,tree.children_left+,+tree.children_right,tree.feature和tree.value..。由于树叶没有分裂，因此没有要素名称和子项，因此它们的占位符在tree.feature和tree.children_***|917p1|有_tree.TREE_UNDEFINED+和_tree.TREE_LEAF..。每个拆分都会被分配一个唯一的索引depth+first+search..。|9fags|请注意，tree.value是形状的[n,+1,+1]^0|1I|E|0|1|I|M|J|16|C|1J|A|2Q|C|33|H|0|1|L|N|F|1L|I|0|4|A|I|9^^$0|$]|1|@$2|3|4|5|6|7|8|M|9|@$A|N|B|O|C|D]]|E|@]|F|$]]|$2|G|4|H|6|7|8|P|9|@$A|Q|B|R|C|D]|$A|S|B|T|C|D]|$A|U|B|V|C|D]|$A|W|B|X|C|D]|$A|Y|B|Z|C|D]|$A|10|B|11|C|D]]|E|@]|F|$]]|$2|I|4|J|6|7|8|12|9|@$A|13|B|14|C|D]|$A|15|B|16|C|D]|$A|17|B|18|C|D]]|E|@]|F|$]]|$2|K|4|L|6|7|8|19|9|@$A|1A|B|1B|C|D]|$A|1C|B|1D|C|D]]|E|@]|F|$]]]]

Thank for the wonderful solution of @paulkerfeld. On top of his solution, for all those who want to have a serialized version of trees, just use <code>tree.threshold</code>, <code>tree.children_left</code>, <code>tree.children_right</code>, <code>tree.feature</code> and <code>tree.value</code>. Since the leaves don't have splits and hence no feature names and children, their placeholder in <code>tree.feature</code> and <code>tree.children_***</code> are <code>_tree.TREE_UNDEFINED</code> and <code>_tree.TREE_LEAF</code>. Every split is assigned a unique index by <code>depth first search</code>. 
 Notice that the <code>tree.value</code> is of shape <code>[n, 1, 1]</code>

entityMap|blocks|key|5ulik|text|下面是一个从决策树生成Python代码的函数，方法是将export_text|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|9gm71|import+string
from+sklearn.tree+import+export_text

def+export_py_code(tree,+feature_names,+max_depth=100,+spacing=4):
++++if+spacing+<+2:
++++++++raise+ValueError('spacing+must+be+>+1')

++++#+Clean+up+feature+names+(for+correctness)
++++nums+=+string.digits
++++alnums+=+string.ascii_letters+%2B+nums
++++clean+=+lambda+s:+''.join(c+if+c+in+alnums+else+'_'+for+c+in+s)
++++features+=+[clean(x)+for+x+in+feature_names]
++++features+=+['_'%2Bx+if+x[0]+in+nums+else+x+for+x+in+features+if+x]
++++if+len(set(features))+!=+len(feature_names):
++++++++raise+ValueError('invalid+feature+names')

++++#+First:+export+tree+to+text
++++res+=+export_text(tree,+feature_names=features,+
++++++++++++++++++++++++max_depth=max_depth,
++++++++++++++++++++++++decimals=6,
++++++++++++++++++++++++spacing=spacing-1)

++++#+Second:+generate+Python+code+from+the+text
++++skip,+dash+=+'+'*spacing,+'-'*(spacing-1)
++++code+=+'def+decision_tree({}):\n'.format(',+'.join(features))
++++for+line+in+repr(tree).split('\n'):
++++++++code+%2B=+skip+%2B+"#+"+%2B+line+%2B+'\n'
++++for+line+in+res.split('\n'):
++++++++line+=+line.rstrip().replace('%7C','+')
++++++++if+'<'+in+line+or+'>'+in+line:
++++++++++++line,+val+=+line.rsplit(maxsplit=1)
++++++++++++line+=+line.replace('+'+%2B+dash,+'if')
++++++++++++line+=+'{}+{:g}:'.format(line,+float(val))
++++++++else:
++++++++++++line+=+line.replace('+{}+class:'.format(dash),+'return')
++++++++code+%2B=+skip+%2B+line+%2B+'\n'

++++return+code|code-block|syntax|javascript|ah6h5|示例用法：|dbmdl|res+=+export_py_code(tree,+feature_names=names,+spacing=4)
print+(res)|d76u0|示例输出：|a912u|def+decision_tree(f1,+f2,+f3):
++++#+DecisionTreeClassifier(class_weight=None,+criterion='gini',+max_depth=3,
++++#++++++++++++++++++++++++max_features=None,+max_leaf_nodes=None,
++++#++++++++++++++++++++++++min_impurity_decrease=0.0,+min_impurity_split=None,
++++#++++++++++++++++++++++++min_samples_leaf=1,+min_samples_split=2,
++++#++++++++++++++++++++++++min_weight_fraction_leaf=0.0,+presort=False,
++++#++++++++++++++++++++++++random_state=42,+splitter='best')
++++if+f1+<=+12.5:
++++++++if+f2+<=+17.5:
++++++++++++if+f1+<=+10.5:
++++++++++++++++return+2
++++++++++++if+f1+>+10.5:
++++++++++++++++return+3
++++++++if+f2+>+17.5:
++++++++++++if+f2+<=+22.5:
++++++++++++++++return+1
++++++++++++if+f2+>+22.5:
++++++++++++++++return+1
++++if+f1+>+12.5:
++++++++if+f1+<=+17.5:
++++++++++++if+f3+<=+23.5:
++++++++++++++++return+2
++++++++++++if+f3+>+23.5:
++++++++++++++++return+3
++++++++if+f1+>+17.5:
++++++++++++if+f1+<=+25:
++++++++++++++++return+1
++++++++++++if+f1+>+25:
++++++++++++++++return+2|8ed97|上面的例子是用names+=+['f'%2Bstr(j%2B1)+for+j+in+range(NUM_FEATURES)]..。|aap7o|一个方便的特性是，它可以生成更小的文件大小和减少的间距。只需设置spacing=2..。^0|R|B|0|0|0|0|0|0|7|1F|0|W|9^^$0|$]|1|@$2|3|4|5|6|7|8|X|9|@$A|Y|B|Z|C|D]]|E|@]|F|$]]|$2|G|4|H|6|I|8|10|9|@]|E|@]|F|$J|K]]|$2|L|4|M|6|7|8|11|9|@]|E|@]|F|$]]|$2|N|4|O|6|I|8|12|9|@]|E|@]|F|$J|K]]|$2|P|4|Q|6|7|8|13|9|@]|E|@]|F|$]]|$2|R|4|S|6|I|8|14|9|@]|E|@]|F|$J|K]]|$2|T|4|U|6|7|8|15|9|@$A|16|B|17|C|D]]|E|@]|F|$]]|$2|V|4|W|6|7|8|18|9|@$A|19|B|1A|C|D]]|E|@]|F|$]]]]

Here is a function that generates Python code from a decision tree by converting the output of <code>export_text</code>:

<pre><code>import string
from sklearn.tree import export_text

def export_py_code(tree, feature_names, max_depth=100, spacing=4):
 if spacing &lt; 2:
 raise ValueError('spacing must be &gt; 1')

 # Clean up feature names (for correctness)
 nums = string.digits
 alnums = string.ascii_letters + nums
 clean = lambda s: ''.join(c if c in alnums else '_' for c in s)
 features = [clean(x) for x in feature_names]
 features = ['_'+x if x[0] in nums else x for x in features if x]
 if len(set(features)) != len(feature_names):
 raise ValueError('invalid feature names')

 # First: export tree to text
 res = export_text(tree, feature_names=features, 
 max_depth=max_depth,
 decimals=6,
 spacing=spacing-1)

 # Second: generate Python code from the text
 skip, dash = ' '*spacing, '-'*(spacing-1)
 code = 'def decision_tree({}):\n'.format(', '.join(features))
 for line in repr(tree).split('\n'):
 code += skip + "# " + line + '\n'
 for line in res.split('\n'):
 line = line.rstrip().replace('|',' ')
 if '&lt;' in line or '&gt;' in line:
 line, val = line.rsplit(maxsplit=1)
 line = line.replace(' ' + dash, 'if')
 line = '{} {:g}:'.format(line, float(val))
 else:
 line = line.replace(' {} class:'.format(dash), 'return')
 code += skip + line + '\n'

 return code
</code></pre>

Sample usage:

<pre><code>res = export_py_code(tree, feature_names=names, spacing=4)
print (res)
</code></pre>

Sample output:

<pre><code>def decision_tree(f1, f2, f3):
 # DecisionTreeClassifier(class_weight=None, criterion='gini', max_depth=3,
 # max_features=None, max_leaf_nodes=None,
 # min_impurity_decrease=0.0, min_impurity_split=None,
 # min_samples_leaf=1, min_samples_split=2,
 # min_weight_fraction_leaf=0.0, presort=False,
 # random_state=42, splitter='best')
 if f1 &lt;= 12.5:
 if f2 &lt;= 17.5:
 if f1 &lt;= 10.5:
 return 2
 if f1 &gt; 10.5:
 return 3
 if f2 &gt; 17.5:
 if f2 &lt;= 22.5:
 return 1
 if f2 &gt; 22.5:
 return 1
 if f1 &gt; 12.5:
 if f1 &lt;= 17.5:
 if f3 &lt;= 23.5:
 return 2
 if f3 &gt; 23.5:
 return 3
 if f1 &gt; 17.5:
 if f1 &lt;= 25:
 return 1
 if f1 &gt; 25:
 return 2
</code></pre>

The above example is generated with <code>names = ['f'+str(j+1) for j in range(NUM_FEATURES)]</code>.

One handy feature is that it can generate smaller file size with reduced spacing. Just set <code>spacing=2</code>.

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://stackoverflow.com/a/65939892/3746632|blocks|key|43cvs|text|从这个答案中，您可以得到一个可读且有效的表示：|unstyled|depth|inlineStyleRanges|entityRanges|26t9c|offset|length|style|UNDERLINE|8dnt4|输出如下所示。X是代表单个实例特征的一维向量。|8m1ur|from+numba+import+jit,njit
@njit
def+predict(X):
++++ret+=+0
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++ret+%2B=+1
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++ret+%2B=+1
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++ret+%2B=+1
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++ret+%2B=+1
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++ret+%2B=+1
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++ret+%2B=+1
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++ret+%2B=+1
++++else:++#+if+w_pizza+>+0.5
++++++++ret+%2B=+1
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++ret+%2B=+1
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++if+X[0]+<=+0.5:+#+if+w_pizza+<=+0.5
++++++++if+X[1]+<=+0.5:+#+if+w_mexico+<=+0.5
++++++++++++if+X[2]+<=+0.5:+#+if+w_reusable+<=+0.5
++++++++++++++++ret+%2B=+1
++++++++++++else:++#+if+w_reusable+>+0.5
++++++++++++++++pass
++++++++else:++#+if+w_mexico+>+0.5
++++++++++++pass
++++else:++#+if+w_pizza+>+0.5
++++++++pass
++++return+ret/10|code-block|syntax|javascript^0|0|0|18|0|18|0|0|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|U|G|@]|H|@]|6|$]]|$A|I|C|8|2|E|F|V|G|@$J|W|K|X|L|M]]|H|@$J|Y|K|Z|A|10]]|6|$]]|$A|N|C|O|2|E|F|11|G|@]|H|@]|6|$]]|$A|P|C|Q|2|R|F|12|G|@]|H|@]|6|$S|T]]]]

From this answer, you get a readable and efficient representation: <a href="https://stackoverflow.com/a/65939892/3746632">https://stackoverflow.com/a/65939892/3746632</a>
Output looks like this. X is 1d vector to represent a single instance's features.
<pre><code>from numba import jit,njit
@njit
def predict(X):
 ret = 0
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 ret += 1
 else: # if w_pizza &gt; 0.5
 pass
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 ret += 1
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 ret += 1
 else: # if w_mexico &gt; 0.5
 ret += 1
 else: # if w_pizza &gt; 0.5
 pass
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 ret += 1
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 ret += 1
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 pass
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 ret += 1
 else: # if w_pizza &gt; 0.5
 ret += 1
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 ret += 1
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 pass
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 pass
 if X[0] &lt;= 0.5: # if w_pizza &lt;= 0.5
 if X[1] &lt;= 0.5: # if w_mexico &lt;= 0.5
 if X[2] &lt;= 0.5: # if w_reusable &lt;= 0.5
 ret += 1
 else: # if w_reusable &gt; 0.5
 pass
 else: # if w_mexico &gt; 0.5
 pass
 else: # if w_pizza &gt; 0.5
 pass
 return ret/10
</code></pre>

entityMap|0|type|LINK|mutability|MUTABLE|data|url|https://mljar.com/blog/extract-rules-decision-tree/|blocks|key|1imlc|text|我需要决策树中更人性化的规则格式。我正在构建开源|unstyled|depth|inlineStyleRanges|entityRanges|bif58|AutoML+Python包，很多时候MLJAR用户希望从树中看到确切的规则。|8jh3l|这就是为什么我实现了一个基于paulkernfeld+回答。|offset|length|style|CODE|4it0m|def+get_rules(tree,+feature_names,+class_names):
++++tree_+=+tree.tree_
++++feature_name+=+[
++++++++feature_names[i]+if+i+!=+_tree.TREE_UNDEFINED+else+"undefined!"
++++++++for+i+in+tree_.feature
++++]

++++paths+=+[]
++++path+=+[]
++++
++++def+recurse(node,+path,+paths):
++++++++
++++++++if+tree_.feature[node]+!=+_tree.TREE_UNDEFINED:
++++++++++++name+=+feature_name[node]
++++++++++++threshold+=+tree_.threshold[node]
++++++++++++p1,+p2+=+list(path),+list(path)
++++++++++++p1+%2B=+[f"({name}+<=+{np.round(threshold,+3)})"]
++++++++++++recurse(tree_.children_left[node],+p1,+paths)
++++++++++++p2+%2B=+[f"({name}+>+{np.round(threshold,+3)})"]
++++++++++++recurse(tree_.children_right[node],+p2,+paths)
++++++++else:
++++++++++++path+%2B=+[(tree_.value[node],+tree_.n_node_samples[node])]
++++++++++++paths+%2B=+[path]
++++++++++++
++++recurse(0,+path,+paths)

++++#+sort+by+samples+count
++++samples_count+=+[p[-1][1]+for+p+in+paths]
++++ii+=+list(np.argsort(samples_count))
++++paths+=+[paths[i]+for+i+in+reversed(ii)]
++++
++++rules+=+[]
++++for+path+in+paths:
++++++++rule+=+"if+"
++++++++
++++++++for+p+in+path[:-1]:
++++++++++++if+rule+!=+"if+":
++++++++++++++++rule+%2B=+"+and+"
++++++++++++rule+%2B=+str(p)
++++++++rule+%2B=+"+then+"
++++++++if+class_names+is+None:
++++++++++++rule+%2B=+"response:+"%2Bstr(np.round(path[-1][0][0][0],3))
++++++++else:
++++++++++++classes+=+path[-1][0][0]
++++++++++++l+=+np.argmax(classes)
++++++++++++rule+%2B=+f"class:+{class_names[l]}+(proba:+{np.round(100.0*classes[l]/np.sum(classes),2)}%25)"
++++++++rule+%2B=+f"+%7C+based+on+{path[-1][1]:,}+samples"
++++++++rules+%2B=+[rule]
++++++++
++++return+rules|code-block|syntax|javascript|amka8|根据分配给每个规则的训练样本数量对规则进行排序。对于每个规则，都有关于预测的类名和分类任务的预测概率的信息。对于回归任务，仅打印有关预测值的信息。|fgjs7|示例|b2sbo|from+sklearn+import+datasets
from+sklearn.tree+import+DecisionTreeRegressor
from+sklearn+import+tree

#+Prepare+the+data+data
boston+=+datasets.load_boston()
X+=+boston.data
y+=+boston.target

#+Fit+the+regressor,+set+max_depth+=+3
regr+=+DecisionTreeRegressor(max_depth=3,+random_state=1234)
model+=+regr.fit(X,+y)

#+Print+rules
rules+=+get_rules(regr,+boston.feature_names,+None)
for+r+in+rules:
++++print(r)|1kr5|打印的规则：|fqle2|if+(RM+<=+6.941)+and+(LSTAT+<=+14.4)+and+(DIS+>+1.385)+then+response:+22.905+%7C+based+on+250+samples
if+(RM+<=+6.941)+and+(LSTAT+>+14.4)+and+(CRIM+<=+6.992)+then+response:+17.138+%7C+based+on+101+samples
if+(RM+<=+6.941)+and+(LSTAT+>+14.4)+and+(CRIM+>+6.992)+then+response:+11.978+%7C+based+on+74+samples
if+(RM+>+6.941)+and+(RM+<=+7.437)+and+(NOX+<=+0.659)+then+response:+33.349+%7C+based+on+43+samples
if+(RM+>+6.941)+and+(RM+>+7.437)+and+(PTRATIO+<=+19.65)+then+response:+45.897+%7C+based+on+29+samples
if+(RM+<=+6.941)+and+(LSTAT+<=+14.4)+and+(DIS+<=+1.385)+then+response:+45.58+%7C+based+on+5+samples
if+(RM+>+6.941)+and+(RM+<=+7.437)+and+(NOX+>+0.659)+then+response:+14.4+%7C+based+on+3+samples
if+(RM+>+6.941)+and+(RM+>+7.437)+and+(PTRATIO+>+19.65)+then+response:+21.9+%7C+based+on+1+samples|42ro|我在我的文章中总结了从决策树中提取规则的方法：|39eqe|Extract+Rules+from+Decision+Tree+in+3+Ways+with+Scikit-Learn+and+Python.|UNDERLINE^0|0|0|E|D|0|0|0|0|0|0|0|0|0|1Z|0|1Z|0^^$0|$1|$2|3|4|5|6|$7|8]]]|9|@$A|B|C|D|2|E|F|1A|G|@]|H|@]|6|$]]|$A|I|C|J|2|E|F|1B|G|@]|H|@]|6|$]]|$A|K|C|L|2|E|F|1C|G|@$M|1D|N|1E|O|P]]|H|@]|6|$]]|$A|Q|C|R|2|S|F|1F|G|@]|H|@]|6|$T|U]]|$A|V|C|W|2|E|F|1G|G|@]|H|@]|6|$]]|$A|X|C|Y|2|E|F|1H|G|@]|H|@]|6|$]]|$A|Z|C|10|2|S|F|1I|G|@]|H|@]|6|$T|U]]|$A|11|C|12|2|E|F|1J|G|@]|H|@]|6|$]]|$A|13|C|14|2|S|F|1K|G|@]|H|@]|6|$T|U]]|$A|15|C|16|2|E|F|1L|G|@]|H|@]|6|$]]|$A|17|C|18|2|E|F|1M|G|@$M|1N|N|1O|O|19]]|H|@$M|1P|N|1Q|A|1R]]|6|$]]]]

I needed a more human-friendly format of rules from the Decision Tree. I'm building open-source <a href="https://github.com/mljar/mljar-supervised" rel="nofollow noreferrer">AutoML</a> Python package and many times MLJAR users want to see the exact rules from the tree.
That's why I implemented a function based on <code>paulkernfeld</code> answer.
<pre class="lang-py prettyprint-override"><code>def get_rules(tree, feature_names, class_names):
 tree_ = tree.tree_
 feature_name = [
 feature_names[i] if i != _tree.TREE_UNDEFINED else &quot;undefined!&quot;
 for i in tree_.feature
 ]

 paths = []
 path = []
 
 def recurse(node, path, paths):
 
 if tree_.feature[node] != _tree.TREE_UNDEFINED:
 name = feature_name[node]
 threshold = tree_.threshold[node]
 p1, p2 = list(path), list(path)
 p1 += [f&quot;({name} &lt;= {np.round(threshold, 3)})&quot;]
 recurse(tree_.children_left[node], p1, paths)
 p2 += [f&quot;({name} &gt; {np.round(threshold, 3)})&quot;]
 recurse(tree_.children_right[node], p2, paths)
 else:
 path += [(tree_.value[node], tree_.n_node_samples[node])]
 paths += [path]
 
 recurse(0, path, paths)

 # sort by samples count
 samples_count = [p[-1][1] for p in paths]
 ii = list(np.argsort(samples_count))
 paths = [paths[i] for i in reversed(ii)]
 
 rules = []
 for path in paths:
 rule = &quot;if &quot;
 
 for p in path[:-1]:
 if rule != &quot;if &quot;:
 rule += &quot; and &quot;
 rule += str(p)
 rule += &quot; then &quot;
 if class_names is None:
 rule += &quot;response: &quot;+str(np.round(path[-1][0][0][0],3))
 else:
 classes = path[-1][0][0]
 l = np.argmax(classes)
 rule += f&quot;class: {class_names[l]} (proba: {np.round(100.0*classes[l]/np.sum(classes),2)}%)&quot;
 rule += f&quot; | based on {path[-1][1]:,} samples&quot;
 rules += [rule]
 
 return rules
</code></pre>
The rules are sorted by the number of training samples assigned to each rule. For each rule, there is information about the predicted class name and probability of prediction for classification tasks. For the regression task, only information about the predicted value is printed.
<h3>Example</h3>
<pre class="lang-py prettyprint-override"><code>from sklearn import datasets
from sklearn.tree import DecisionTreeRegressor
from sklearn import tree

# Prepare the data data
boston = datasets.load_boston()
X = boston.data
y = boston.target

# Fit the regressor, set max_depth = 3
regr = DecisionTreeRegressor(max_depth=3, random_state=1234)
model = regr.fit(X, y)

# Print rules
rules = get_rules(regr, boston.feature_names, None)
for r in rules:
 print(r)
</code></pre>
The printed rules:
<pre class="lang-py prettyprint-override"><code>if (RM &lt;= 6.941) and (LSTAT &lt;= 14.4) and (DIS &gt; 1.385) then response: 22.905 | based on 250 samples
if (RM &lt;= 6.941) and (LSTAT &gt; 14.4) and (CRIM &lt;= 6.992) then response: 17.138 | based on 101 samples
if (RM &lt;= 6.941) and (LSTAT &gt; 14.4) and (CRIM &gt; 6.992) then response: 11.978 | based on 74 samples
if (RM &gt; 6.941) and (RM &lt;= 7.437) and (NOX &lt;= 0.659) then response: 33.349 | based on 43 samples
if (RM &gt; 6.941) and (RM &gt; 7.437) and (PTRATIO &lt;= 19.65) then response: 45.897 | based on 29 samples
if (RM &lt;= 6.941) and (LSTAT &lt;= 14.4) and (DIS &lt;= 1.385) then response: 45.58 | based on 5 samples
if (RM &gt; 6.941) and (RM &lt;= 7.437) and (NOX &gt; 0.659) then response: 14.4 | based on 3 samples
if (RM &gt; 6.941) and (RM &gt; 7.437) and (PTRATIO &gt; 19.65) then response: 21.9 | based on 1 samples
</code></pre>
I've summarized the ways to extract rules from the Decision Tree in my article: <a href="https://mljar.com/blog/extract-rules-decision-tree/" rel="nofollow noreferrer">Extract Rules from Decision Tree in 3 Ways with Scikit-Learn and Python</a>.

Can I extract the underlying decision-rules (or 'decision paths') from a trained tree in a decision tree as a textual list?
Something like:
<pre><code>if A&gt;0.4 then if B&lt;0.2 then if C&gt;0.8 then class='X'
</code></pre>

How to extract the decision rules from scikit-learn decision-tree?

Python

我可以从决策树中经过训练的树中提取底层决策规则(或‘决策路径’)作为文本列表吗？ 类似于： if A>0.4 then if B<0.2 then if C>0.8 then class='X' 谢谢你的帮助。

问如何从scikit-learn决策树中提取决策规则？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从scikit-learn决策树中提取决策规则？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从scikit-learn决策树中提取决策规则？
EN