Merge pull request #1420 from astaric/tree-interface

Tree: Common mixin for regression and classification tree

Author: BlazZupan

Orange/base.py

@@ -266,3 +266,40 @@ def supports_weights(self):
         """Indicates whether this learner supports weighted instances.
         """
         return 'sample_weight' in self.__wraps__.fit.__code__.co_varnames
+
+
+class Tree:
+    """Interface for tree based models.
+
+    Defines members needed for drawing of the tree.
+    """
+
+    #: Domain of data the tree was built from
+    domain = None
+
+    #: Data the tree was built from (Optional)
+    instances = None
+
+    @property
+    def tree(self):
+        """Return underlying tree representation
+
+        Returns
+        -------
+        sklearn.tree._tree.Tree
+        """
+        raise NotImplementedError()
+
+
+class RandomForest:
+    """Interface for random forest models
+    """
+
+    @property
+    def trees(self):
+        """Return a list of Trees in the forest
+
+        Returns
+        -------
+        List[Tree]
+        """

Orange/classification/random_forest.py

@@ -1,6 +1,8 @@
 import sklearn.ensemble as skl_ensemble
 
+from Orange.base import RandomForest
 from Orange.classification import SklLearner, SklModel
+from Orange.classification.tree import TreeClassifier
 from Orange.data import Variable, DiscreteVariable
 from Orange.preprocess.score import LearnerScorer
 
@@ -16,8 +18,19 @@ def score(self, data):
         return model.skl_model.feature_importances_
 
 
-class RandomForestClassifier(SklModel):
-    pass
+class RandomForestClassifier(SklModel, RandomForest):
+    @property
+    def trees(self):
+        def wrap(tree, i):
+            t = TreeClassifier(tree)
+            t.domain = self.domain
+            t.supports_multiclass = self.supports_multiclass
+            t.name = "{} - tree {}".format(self.name, i)
+            t.original_domain = self.original_domain
+            return t
+
+        return [wrap(tree, i)
+                for i, tree in enumerate(self.skl_model.estimators_)]
 
 
 class RandomForestLearner(SklLearner, _FeatureScorerMixin):

Orange/classification/tree.py

@@ -1,13 +1,17 @@
 import sklearn.tree as skl_tree
+
+from Orange.base import Tree
 from Orange.classification import SklLearner, SklModel
 from Orange.preprocess import (RemoveNaNClasses, Continuize,
                                RemoveNaNColumns, SklImpute)
 
 __all__ = ["TreeLearner"]
 
 
-class TreeClassifier(SklModel):
-    pass
+class TreeClassifier(SklModel, Tree):
+    @property
+    def tree(self):
+        return self.skl_model.tree_
 
 
 class TreeLearner(SklLearner):

Orange/regression/random_forest.py

@@ -1,7 +1,10 @@
 import sklearn.ensemble as skl_ensemble
+
+from Orange.base import RandomForest
 from Orange.regression import SklLearner, SklModel
 from Orange.data import Variable, ContinuousVariable
 from Orange.preprocess.score import LearnerScorer
+from Orange.regression.tree import TreeRegressor
 
 __all__ = ["RandomForestRegressionLearner"]
 
@@ -15,8 +18,19 @@ def score(self, data):
         return model.skl_model.feature_importances_
 
 
-class RandomForestRegressor(SklModel):
-    pass
+class RandomForestRegressor(SklModel, RandomForest):
+    @property
+    def trees(self):
+        def wrap(tree, i):
+            t = TreeRegressor(tree)
+            t.domain = self.domain
+            t.supports_multiclass = self.supports_multiclass
+            t.name = "{} - tree {}".format(self.name, i)
+            t.original_domain = self.original_domain
+            return t
+
+        return [wrap(tree, i)
+                for i, tree in enumerate(self.skl_model.estimators_)]
 
 
 class RandomForestRegressionLearner(SklLearner, _FeatureScorerMixin):

Orange/regression/tree.py

@@ -1,12 +1,16 @@
 import sklearn.tree as skl_tree
+
+from Orange.base import Tree
 from Orange.regression import SklLearner, SklModel
 from Orange.preprocess import Continuize, RemoveNaNColumns, SklImpute
 
 __all__ = ["TreeRegressionLearner"]
 
 
-class TreeRegressor(SklModel):
-    pass
+class TreeRegressor(SklModel, Tree):
+    @property
+    def tree(self):
+        return self.skl_model.tree_
 
 
 class TreeRegressionLearner(SklLearner):

Orange/tests/test_random_forest.py

@@ -9,11 +9,12 @@
 from Orange.regression import RandomForestRegressionLearner
 from Orange.tests import test_filename
 
+
 class RandomForestTest(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
         cls.iris = Table('iris')
-        cls.house = Table('housing')
+        cls.housing = Table('housing')
 
     def test_RandomForest(self):
         forest = RandomForestLearner()
@@ -43,28 +44,28 @@ def test_predict_numpy(self):
 
     def test_RandomForestRegression(self):
         forest = RandomForestRegressionLearner()
-        results = CrossValidation(self.house, [forest], k=10)
+        results = CrossValidation(self.housing, [forest], k=10)
         _ = RMSE(results)
 
     def test_predict_single_instance_reg(self):
         forest = RandomForestRegressionLearner()
-        model = forest(self.house)
-        for ins in self.house:
+        model = forest(self.housing)
+        for ins in self.housing:
             pred = model(ins)
             self.assertGreater(pred, 0)
 
     def test_predict_table_reg(self):
         forest = RandomForestRegressionLearner()
-        model = forest(self.house)
-        pred = model(self.house)
-        self.assertEqual(len(self.house), len(pred))
+        model = forest(self.housing)
+        pred = model(self.housing)
+        self.assertEqual(len(self.housing), len(pred))
         self.assertGreater(all(pred), 0)
 
     def test_predict_numpy_reg(self):
         forest = RandomForestRegressionLearner()
-        model = forest(self.house)
-        pred = model(self.house.X)
-        self.assertEqual(len(self.house), len(pred))
+        model = forest(self.housing)
+        pred = model(self.housing.X)
+        self.assertEqual(len(self.housing), len(pred))
         self.assertGreater(all(pred), 0)
 
     def test_classification_scorer(self):
@@ -78,9 +79,9 @@ def test_classification_scorer(self):
 
     def test_regression_scorer(self):
         learner = RandomForestRegressionLearner()
-        scores = learner.score_data(self.house)
+        scores = learner.score_data(self.housing)
         self.assertEqual(['LSTAT', 'RM'],
-                         sorted([self.house.domain.attributes[i].name
+                         sorted([self.housing.domain.attributes[i].name
                                  for i in np.argsort(scores[0])[-2:]]))
 
     def test_scorer_feature(self):
@@ -92,3 +93,19 @@ def test_scorer_feature(self):
             np.random.seed(42)
             score = learner.score_data(data, attr)
             np.testing.assert_array_almost_equal(score, scores[:, i])
+
+    def test_get_classification_trees(self):
+        n = 5
+        forest = RandomForestLearner(n_estimators=n)
+        model = forest(self.iris)
+        self.assertEqual(len(model.trees), n)
+        tree = model.trees[0]
+        self.assertEqual(tree(self.iris[0]), 0)
+
+    def test_get_regression_trees(self):
+        n = 5
+        forest = RandomForestRegressionLearner(n_estimators=n)
+        model = forest(self.housing)
+        self.assertEqual(len(model.trees), n)
+        tree = model.trees[0]
+        tree(self.housing[0])

Orange/tests/test_tree.py

@@ -5,7 +5,7 @@
 
 import numpy as np
 import sklearn.tree as skl_tree
-from sklearn.tree._tree import TREE_LEAF
+from sklearn.tree._tree import TREE_LEAF, Tree
 
 from Orange.data import Table
 from Orange.classification import TreeLearner
@@ -27,6 +27,18 @@ def test_regression(self):
         pred = model(table)
         self.assertTrue(np.all(table.Y.flatten() == pred))
 
+    def test_get_tree_classification(self):
+        table = Table('iris')
+        learn = TreeLearner()
+        clf = learn(table)
+        self.assertIsInstance(clf.tree, Tree)
+
+    def test_get_tree_regression(self):
+        table = Table('housing')
+        learn = TreeRegressionLearner()
+        clf = learn(table)
+        self.assertIsInstance(clf.tree, Tree)
+
 
 class TestDecisionTreeClassifier(unittest.TestCase):
     @classmethod