first approx to grapher

trees/Siterator.py

@@ -4,14 +4,13 @@ __copyright__ = "Copyright 2020, Ricardo Montañana Gómez"
 __license__ = "MIT"
 __version__ = "0.9"
 Inorder iterator for the binary tree of Snodes
-Uses LinearSVC
 '''
 
 from trees.Snode import Snode
 
 
 class Siterator:
-    """Inorder iterator
+    """Stree preorder iterator
     """
 
     def __init__(self, tree: Snode):
@@ -22,13 +21,13 @@ class Siterator:
         return self
 
     def _push(self, node: Snode):
-        while (node is not None):
-            self._stack.insert(0, node)
-            node = node.get_down()
+        if node is not None:
+            self._stack.append(node)
 
     def __next__(self) -> Snode:
         if len(self._stack) == 0:
             raise StopIteration()
         node = self._stack.pop()
         self._push(node.get_up())
+        self._push(node.get_down())
         return node

trees/Snode.py

@@ -11,7 +11,6 @@ import os
 import numpy as np
 from sklearn.svm import LinearSVC
 
-
 class Snode:
     def __init__(self, clf: LinearSVC, X: np.ndarray, y: np.ndarray, title: str):
         self._clf = clf
@@ -26,6 +25,10 @@ class Snode:
         self._up = None
         self._class = None
 
+    @classmethod
+    def copy(cls, node: 'Snode') -> 'Snode':
+        return cls(node._clf, node._X, node._y, node._title)
+
     def set_down(self, son):
         self._down = son
 
@@ -45,9 +48,6 @@ class Snode:
         """Compute the class of the predictor and its belief based on the subdataset of the node
         only if it is a leaf
         """
-        # Clean memory
-        #self._X = None
-        #self._y = None
         if not self.is_leaf():
             return
         classes, card = np.unique(self._y, return_counts=True)
@@ -67,4 +67,4 @@ class Snode:
         if self.is_leaf():
             return f"{self._title} - Leaf class={self._class} belief={self._belief:.6f} counts={np.unique(self._y, return_counts=True)}"
         else:
-            return f"{self._title}"
+            return f"{self._title}"

trees/Snode_graph.py

@@ -0,0 +1,49 @@
+'''
+__author__ = "Ricardo Montañana Gómez"
+__copyright__ = "Copyright 2020, Ricardo Montañana Gómez"
+__license__ = "MIT"
+__version__ = "0.9"
+Plot 3D views of nodes in Stree
+'''
+
+import numpy as np
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from trees.Snode import Snode
+from trees.Stree import Stree
+
+
+class Snode_graph(Snode):
+
+    def __init__(self, node: Stree):
+        self._plot_size = (8, 8)
+        n = Snode.copy(node)
+        super().__init__(n._clf, n._X, n._y, n._title)
+
+    def set_plot_size(self, size):
+        self._plot_size = size
+
+    def plot_hyperplane(self):
+        # get the splitting hyperplane
+        def hyperplane(x, y): return (-self._interceptor - self._vector[0][0] * x
+                                      - self._vector[0][1] * y) / self._vector[0][2]
+        fig = plt.figure(figsize=self._plot_size)
+        ax = fig.add_subplot(1, 1, 1, projection='3d')
+        tmpx = np.linspace(self._X[:, 0].min(), self._X[:, 0].max())
+        tmpy = np.linspace(self._X[:, 1].min(), self._X[:, 1].max())
+        xx, yy = np.meshgrid(tmpx, tmpy)
+        ax.plot_surface(xx, yy, hyperplane(xx, yy), alpha=.5, antialiased=True,
+                        rstride=1, cstride=1, cmap='seismic')
+        plt.title(self._title)
+        self.plot_distribution(ax)
+        return ax
+
+    def plot_distribution(self, ax: Axes3D = None):
+        if ax is None:
+            fig = plt.figure(figsize=self._plot_size)
+            ax = fig.add_subplot(1, 1, 1, projection='3d')
+        ax.scatter(self._X[:, 0], self._X[:, 1], self._X[:, 2], c=self._y)
+        ax.set_xlabel('X0')
+        ax.set_ylabel('X1')
+        ax.set_zlabel('X2')
+        plt.show()

trees/Stree.py

@@ -13,7 +13,6 @@ import numpy as np
 from sklearn.base import BaseEstimator, ClassifierMixin
 from sklearn.svm import LinearSVC
 from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
-
 from trees.Snode import Snode
 from trees.Siterator import Siterator
 
@@ -22,7 +21,7 @@ class Stree(BaseEstimator, ClassifierMixin):
     """
     """
 
-    def __init__(self, C=1.0, max_iter: int = 1000, random_state: int = 0, use_predictions: bool = False):
+    def __init__(self, C: float=1.0, max_iter: int = 1000, random_state: int = 0, use_predictions: bool = False):
         self._max_iter = max_iter
         self._C = C
         self._random_state = random_state

trees/Stree_grapher.py

@@ -0,0 +1,51 @@
+'''
+__author__ = "Ricardo Montañana Gómez"
+__copyright__ = "Copyright 2020, Ricardo Montañana Gómez"
+__license__ = "MIT"
+__version__ = "0.9"
+Plot 3D views of nodes in Stree
+'''
+
+import os
+import numpy as np
+from sklearn.decomposition import PCA
+import trees
+import matplotlib.pyplot as plt
+from trees.Snode import Snode
+from trees.Snode_graph import Snode_graph
+from trees.Stree import Stree
+from trees.Siterator import Siterator
+
+class Stree_grapher(Stree):
+    def __init__(self, params: dict):
+        self._plot_size = (8, 8)
+        self._tree_gr = None
+        # make Snode store X's
+        os.environ['TESTING'] = '1'
+        super().__init__(**params)
+        
+    def __del__(self):
+        try:
+            os.environ.pop('TESTING')
+        except:
+            pass
+        plt.close('all')
+
+    def _copy_tree(self, node: Snode) -> Snode_graph:
+        mirror = Snode_graph(node)
+        if node.get_down() is not None:
+            mirror.set_down(self._copy_tree(node.get_down()))
+        if node.get_up() is not None:
+            mirror.set_up(self._copy_tree(node.get_up()))
+        return mirror
+
+    def fit(self, X: np.array, y: np.array) -> Stree:
+        if X.shape[1] != 3:
+            pca = PCA(n_components=3)
+            X = pca.fit_transform(X)
+        res = super().fit(X, y)
+        self._tree_gr = self._copy_tree(self._tree)
+        return res
+
+    def __iter__(self):
+        return Siterator(self._tree_gr)