RandomForest: Common mixin for regression and classification

Author: astaric

Orange/base.py

@@ -289,3 +289,17 @@ def tree(self):
         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/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/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])