[MRG] Matplotlib tree plotting (scikit-learn#9251)

* add reingold tillford tree layout algorithm * add first silly implementation of matplotlib based plotting for trees * object oriented design for export_graphviz so it can be extended * add class for mlp export * add colors * separately scale x and y, add arrowheads, fix strings * implement max_depth * don't use alpha for coloring because it makes boxes transparent * remove unused variables * vertical center of boxes * fix/simplify newline trimming * somewhere in the middle of stuff trying to get rid of scalex, scaley * remove "find_longest_child" for now, fix tests * make scalex and scaley internal, and ax local. render everything once to get the bbox sizes, then again to actually plot it with known extents. * add some margin to the max bbox width * add _BaseTreeExporter baseclass * add docstring to plot_tree * use data coordinates so we can put the plot in a subplot, remove some hacks. * remove scalex, scaley, add automatic font size * use rendered stuff for setting limits (well nearly there) * import plot_tree into tree module * set limits before font size adjustment? * add tree plotting via matplotlib to iris example and to docs * pep8 fix * skip doctest on plot_tree because matplotlib is not installed on all CI machines * redo everything in axis pixel coordinates re-introduce scalex, scaley add max_extents to tree to get tree size before plotting * fix max-depth parent node positioning and don't consider deep nodes in layouting * consider height in fontsize computation in case someone gave us a very flat figure * fix error when max_depth is None * add docstring for tree plotting fontsize * starting on jnothman's review * renaming fixes * whatsnew for tree plotting * clear axes prior to doing anything. * fix doctests * skip matplotlib doctest * trying to debug circle failure * trying to show full traceback * more print debugging * remove debugging crud * hack around matplotlib <1.5 issues * copy bbox args because old matplotlib is weird. * pep8 fixes * add explicit boxstyle * more pep8 * even more pep8 * add comment about matplotlib version requirement * remove redundant file * add whatsnew entry that the merge lost * fix merge issue * more merge issues * whitespace ... * remove doctest skip to see what's happening * added some simple invariance tests buchheim function * refactor ___init__ into superclass * added some tests of plot_tree * put skip back in, fix typo, fix versionadded number * remove unused parameters special_characters and parallel_leaves from mpl plotting * rename tests to test_reingold_tilford * added license header from pymag-trees repo * remove duplicate test file.

Author: amueller

doc/Makefile

@@ -13,7 +13,7 @@ endif
 # Internal variables.
 PAPEROPT_a4 = -D latex_paper_size=a4
 PAPEROPT_letter = -D latex_paper_size=letter
-ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS)\
+ALLSPHINXOPTS = -T -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS)\
  $(EXAMPLES_PATTERN_OPTS) .
 
 

doc/modules/tree.rst

@@ -124,9 +124,20 @@ Using the Iris dataset, we can construct a tree as follows::
  >>> clf = tree.DecisionTreeClassifier()
  >>> clf = clf.fit(iris.data, iris.target)
 
-Once trained, we can export the tree in `Graphviz
+Once trained, you can plot the tree with the plot_tree function::
+
+
+ >>> tree.plot_tree(clf.fit(iris.data, iris.target)) # doctest: +SKIP
+
+.. figure:: ../auto_examples/tree/images/sphx_glr_plot_iris_002.png
+ :target: ../auto_examples/tree/plot_iris.html
+ :scale: 75
+ :align: center
+
+We can also export the tree in `Graphviz
 <https://www.graphviz.org/>`_ format using the :func:`export_graphviz`
-exporter. If you use the `conda <https://conda.io/>`_ package manager, the graphviz binaries 
+exporter. If you use the `conda <https://conda.io>`_ package manager, the graphviz binaries 
+
 and the python package can be installed with 
 
  conda install python-graphviz

doc/whats_new/v0.21.rst

@@ -62,6 +62,11 @@ Support for Python 3.4 and below has been officially dropped.
 
 :mod:`sklearn.tree`
 ...................
+- Decision Trees can now be plotted with matplotlib using
+ :func:`tree.export.plot_tree` without relying on the ``dot`` library,
+ removing a hard-to-install dependency.
+ :issue:`8508` by `Andreas Müller`_.
+
 - |Feature| ``get_n_leaves()`` and ``get_depth()`` have been added to
  :class:`tree.BaseDecisionTree` and consequently all estimators based
  on it, including :class:`tree.DecisionTreeClassifier`,

examples/tree/plot_iris.py

@@ -11,14 +11,16 @@
 For each pair of iris features, the decision tree learns decision
 boundaries made of combinations of simple thresholding rules inferred from
 the training samples.
+
+We also show the tree structure of a model built on all of the features.
 """
 print(__doc__)
 
 import numpy as np
 import matplotlib.pyplot as plt
 
 from sklearn.datasets import load_iris
-from sklearn.tree import DecisionTreeClassifier
+from sklearn.tree import DecisionTreeClassifier, plot_tree
 
 # Parameters
 n_classes = 3
@@ -62,4 +64,8 @@
 plt.suptitle("Decision surface of a decision tree using paired features")
 plt.legend(loc='lower right', borderpad=0, handletextpad=0)
 plt.axis("tight")
+
+plt.figure()
+clf = DecisionTreeClassifier().fit(iris.data, iris.target)
+plot_tree(clf, filled=True)
 plt.show()

sklearn/tree/__init__.py

@@ -7,7 +7,8 @@
 from .tree import DecisionTreeRegressor
 from .tree import ExtraTreeClassifier
 from .tree import ExtraTreeRegressor
-from .export import export_graphviz
+from .export import export_graphviz, plot_tree
 
 __all__ = ["DecisionTreeClassifier", "DecisionTreeRegressor",
- "ExtraTreeClassifier", "ExtraTreeRegressor", "export_graphviz"]
+ "ExtraTreeClassifier", "ExtraTreeRegressor", "export_graphviz",
+ "plot_tree"]

sklearn/tree/_reingold_tilford.py

@@ -0,0 +1,203 @@
+# taken from https://github.com/llimllib/pymag-trees/blob/master/buchheim.py
+# with slight modifications
+
+# DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# Version 2, December 2004
+#
+# Copyright (C) 2004 Sam Hocevar <sam@hocevar.net>
+#
+# Everyone is permitted to copy and distribute verbatim or modified
+# copies of this license document, and changing it is allowed as long
+# as the name is changed.
+#
+# DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
+# TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+# 0. You just DO WHAT THE FUCK YOU WANT TO.
+
+
+import numpy as np
+
+
+class DrawTree(object):
+ def __init__(self, tree, parent=None, depth=0, number=1):
+ self.x = -1.
+ self.y = depth
+ self.tree = tree
+ self.children = [DrawTree(c, self, depth + 1, i + 1)
+ for i, c
+ in enumerate(tree.children)]
+ self.parent = parent
+ self.thread = None
+ self.mod = 0
+ self.ancestor = self
+ self.change = self.shift = 0
+ self._lmost_sibling = None
+ # this is the number of the node in its group of siblings 1..n
+ self.number = number
+
+ def left(self):
+ return self.thread or len(self.children) and self.children[0]
+
+ def right(self):
+ return self.thread or len(self.children) and self.children[-1]
+
+ def lbrother(self):
+ n = None
+ if self.parent:
+ for node in self.parent.children:
+ if node == self:
+ return n
+ else:
+ n = node
+ return n
+
+ def get_lmost_sibling(self):
+ if not self._lmost_sibling and self.parent and self != \
+ self.parent.children[0]:
+ self._lmost_sibling = self.parent.children[0]
+ return self._lmost_sibling
+ lmost_sibling = property(get_lmost_sibling)
+
+ def __str__(self):
+ return "%s: x=%s mod=%s" % (self.tree, self.x, self.mod)
+
+ def __repr__(self):
+ return self.__str__()
+
+ def max_extents(self):
+ extents = [c.max_extents() for c in self. children]
+ extents.append((self.x, self.y))
+ return np.max(extents, axis=0)
+
+
+def buchheim(tree):
+ dt = first_walk(DrawTree(tree))
+ min = second_walk(dt)
+ if min < 0:
+ third_walk(dt, -min)
+ return dt
+
+
+def third_walk(tree, n):
+ tree.x += n
+ for c in tree.children:
+ third_walk(c, n)
+
+
+def first_walk(v, distance=1.):
+ if len(v.children) == 0:
+ if v.lmost_sibling:
+ v.x = v.lbrother().x + distance
+ else:
+ v.x = 0.
+ else:
+ default_ancestor = v.children[0]
+ for w in v.children:
+ first_walk(w)
+ default_ancestor = apportion(w, default_ancestor, distance)
+ # print("finished v =", v.tree, "children")
+ execute_shifts(v)
+
+ midpoint = (v.children[0].x + v.children[-1].x) / 2
+
+ w = v.lbrother()
+ if w:
+ v.x = w.x + distance
+ v.mod = v.x - midpoint
+ else:
+ v.x = midpoint
+ return v
+
+
+def apportion(v, default_ancestor, distance):
+ w = v.lbrother()
+ if w is not None:
+ # in buchheim notation:
+ # i == inner; o == outer; r == right; l == left; r = +; l = -
+ vir = vor = v
+ vil = w
+ vol = v.lmost_sibling
+ sir = sor = v.mod
+ sil = vil.mod
+ sol = vol.mod
+ while vil.right() and vir.left():
+ vil = vil.right()
+ vir = vir.left()
+ vol = vol.left()
+ vor = vor.right()
+ vor.ancestor = v
+ shift = (vil.x + sil) - (vir.x + sir) + distance
+ if shift > 0:
+ move_subtree(ancestor(vil, v, default_ancestor), v, shift)
+ sir = sir + shift
+ sor = sor + shift
+ sil += vil.mod
+ sir += vir.mod
+ sol += vol.mod
+ sor += vor.mod
+ if vil.right() and not vor.right():
+ vor.thread = vil.right()
+ vor.mod += sil - sor
+ else:
+ if vir.left() and not vol.left():
+ vol.thread = vir.left()
+ vol.mod += sir - sol
+ default_ancestor = v
+ return default_ancestor
+
+
+def move_subtree(wl, wr, shift):
+ subtrees = wr.number - wl.number
+ # print(wl.tree, "is conflicted with", wr.tree, 'moving', subtrees,
+ # 'shift', shift)
+ # print wl, wr, wr.number, wl.number, shift, subtrees, shift/subtrees
+ wr.change -= shift / subtrees
+ wr.shift += shift
+ wl.change += shift / subtrees
+ wr.x += shift
+ wr.mod += shift
+
+
+def execute_shifts(v):
+ shift = change = 0
+ for w in v.children[::-1]:
+ # print("shift:", w, shift, w.change)
+ w.x += shift
+ w.mod += shift
+ change += w.change
+ shift += w.shift + change
+
+
+def ancestor(vil, v, default_ancestor):
+ # the relevant text is at the bottom of page 7 of
+ # "Improving Walker's Algorithm to Run in Linear Time" by Buchheim et al,
+ # (2002)
+ # http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.16.8757&rep=rep1&type=pdf
+ if vil.ancestor in v.parent.children:
+ return vil.ancestor
+ else:
+ return default_ancestor
+
+
+def second_walk(v, m=0, depth=0, min=None):
+ v.x += m
+ v.y = depth
+
+ if min is None or v.x < min:
+ min = v.x
+
+ for w in v.children:
+ min = second_walk(w, m + v.mod, depth + 1, min)
+
+ return min
+
+
+class Tree(object):
+ def __init__(self, label="", node_id=-1, *children):
+ self.label = label
+ self.node_id = node_id
+ if children:
+ self.children = children
+ else:
+ self.children = []