compute predictor and store model in node

trees/Snode.py

@@ -3,47 +3,63 @@ __author__ = "Ricardo Montañana Gómez"
 __copyright__ = "Copyright 2020, Ricardo Montañana Gómez"
 __license__ = "MIT"
 __version__ = "1.0"
-Node of the Stree
+Node of the Stree (binary tree)
 '''
 
 import numpy as np
+from sklearn.svm import LinearSVC
+
 
 class Snode:
-    def __init__(self, vector: np.ndarray, interceptor: float, X: np.ndarray, y: np.ndarray, title: str):
-        self._vector = vector
-        self._interceptor = interceptor
+    def __init__(self, model: LinearSVC, X: np.ndarray, y: np.ndarray, title: str):
+        self._model = model
+        self._vector = None if model is None else model.coef_
+        self._interceptor = 0 if model is None else model.intercept_
         self._title = title
+        self._belief = 0  # belief of the prediction in a leaf node based on samples
         self._X = X
         self._y = y
         self._down = None
         self._up = None
-        self._class = None # really needed?
-    
+        self._class = None  # really needed?
+
     def set_down(self, son):
         self._down = son
-    
+
     def set_up(self, son):
         self._up = son
 
     def is_leaf(self,) -> bool:
         return self._up is None and self._down is None
-    
+
     def get_down(self) -> 'Snode':
         return self._down
 
     def get_up(self) -> 'Snode':
         return self._up
 
+    def make_predictor(self):
+        """Compute the class of the predictor and its belief based on the subdataset of the node
+        only if it is a leaf
+        """
+        if not self.is_leaf():
+            return
+        classes, card = np.unique(self._y, return_counts=True)
+        max_card = max(card)
+        min_card = min(card)
+        try:
+            self._belief = max_card / min_card
+        except:
+            self._belief = 0
+        self._class = classes[card == max_card]
+
     def __str__(self) -> str:
         if self.is_leaf():
             num = 0
             for i in np.unique(self._y):
                 num = max(num, self._y[self._y == i].shape[0])
             den = self._y.shape[0]
-            accuracy = num / den if den != 0 else 1       
-            return f"{self._title} LEAF accuracy={accuracy:.2f}"
+            accuracy = num / den if den != 0 else 1
+            return f"{self._title} LEAF accuracy={accuracy:.2f}\n"
         else:
-            return self._title
-
-    
-    
+            return f"{self._title}\n"