change the way of spreading grid points; version 0.2.0

Author: [zebinyang]

setup.py

@@ -1,7 +1,7 @@
 from setuptools import setup
 
 setup(name='simtree',
-      version='0.1.8',
+      version='0.2.0',
       description='Single-index model tree',
       url='https://github.com/ZebinYang/SIMTree',
       author='Zebin Yang',

simtree/__init__.py

@@ -8,5 +8,5 @@
         "SIMTreeRegressor", "SIMTreeClassifier",
         "CustomMobTreeRegressor", "CustomMobTreeClassifier"]
 
-__version__ = '0.1.8'
+__version__ = '0.2.0'
 __author__ = 'Zebin Yang'

simtree/cart.py

@@ -55,24 +55,12 @@ def node_split(self, sample_indice):
             sq_sum_total = np.sum(node_y ** 2)
             for i, _ in enumerate(sortted_indice):
 
+                if ((i + 1) < self.min_samples_leaf) or ((n_samples - i - 1) < self.min_samples_leaf):
+                    continue
+
                 n_left = i + 1
                 n_right = n_samples - i - 1
                 sum_left += node_y[sortted_indice[i]]
-                if i == (n_samples - 1):
-                    continue
-
-                if sortted_feature[i + 1] <= sortted_feature[i] + self.EPSILON:
-                    continue
-
-                if self.min_samples_leaf < n_samples / (self.n_split_grid - 1):
-                    if (i + 1) / n_samples < (split_point + 1) / (self.n_split_grid + 1):
-                        continue
-                elif n_samples > 2 * self.min_samples_leaf:
-                    if (i + 1 - self.min_samples_leaf) / (n_samples - 2 * self.min_samples_leaf) < split_point / (self.n_split_grid - 1):
-                        continue
-                elif (i + 1) != self.min_samples_leaf:
-                    continue
-
                 current_impurity = (sq_sum_total / n_samples - (sum_left / n_left) ** 2 * n_left / n_samples -
                              ((sum_total - sum_left) / n_right) ** 2 * n_right / n_samples)
 
@@ -144,23 +132,12 @@ def node_split(self, sample_indice):
             sum_total = np.sum(node_y)
             for i, _ in enumerate(sortted_indice):
 
+                if ((i + 1) < self.min_samples_leaf) or ((n_samples - i - 1) < self.min_samples_leaf):
+                    continue
+
                 n_left = i + 1
                 n_right = n_samples - i - 1
                 sum_left += node_y[sortted_indice[i]]
-                if i == (n_samples - 1):
-                    continue
-
-                if sortted_feature[i + 1] <= sortted_feature[i] + self.EPSILON:
-                    continue
-
-                if self.min_samples_leaf < n_samples / (self.n_split_grid - 1):
-                    if (i + 1) / n_samples < (split_point + 1) / (self.n_split_grid + 1):
-                        continue
-                elif n_samples > 2 * self.min_samples_leaf:
-                    if (i + 1 - self.min_samples_leaf) / (n_samples - 2 * self.min_samples_leaf) < split_point / (self.n_split_grid - 1):
-                        continue
-                elif (i + 1) != self.min_samples_leaf:
-                    continue
 
                 left_impurity = 0
                 right_impurity = 0

simtree/mobtree.py

@@ -99,29 +99,14 @@ def screen_features(self, sample_indice):
             if feature_range < self.EPSILON:
                 continue
 
-            split_point = 0
             best_impurity = np.inf
-            for i, _ in enumerate(sortted_indice):
-
-                if i == (n_samples - 1):
-                    continue
-
+            split_points = np.quantile(sortted_feature, np.linspace(0, 1, self.n_screen_grid + 2)[1:-1], interpolation='lower')
+            for split_point in split_points:
+                
+                i = abs(sortted_feature - split_point).argmin()
                 if ((i + 1) < self.min_samples_leaf) or ((n_samples - i - 1) < self.min_samples_leaf):
                     continue
 
-                if sortted_feature[i + 1] <= sortted_feature[i] + self.EPSILON:
-                    continue
-
-                if self.min_samples_leaf < n_samples / max((self.n_screen_grid - 1), 2):
-                    if (i + 1) / n_samples < (split_point + 1) / (self.n_screen_grid + 1):
-                        continue
-                elif n_samples > 2 * self.min_samples_leaf:
-                    if (i + 1 - self.min_samples_leaf) / (n_samples - 2 * self.min_samples_leaf) < split_point / (self.n_screen_grid - 1):
-                        continue
-                elif (i + 1) != self.min_samples_leaf:
-                    continue
-
-                split_point += 1
                 left_indice = sortted_indice[:(i + 1)]
                 if node_y[left_indice].std() == 0:
                     left_impurity = 0
@@ -167,28 +152,14 @@ def node_split(self, sample_indice):
             if feature_range < self.EPSILON:
                 continue
 
-            split_point = 0
-            for i, _ in enumerate(sortted_indice):
-
-                if i == (n_samples - 1):
-                    continue
+            best_impurity = np.inf
+            split_points = np.quantile(sortted_feature, np.linspace(0, 1, self.n_split_grid + 2)[1:-1], interpolation='lower')
+            for split_point in split_points:
 
+                i = abs(sortted_feature - split_point).argmin()
                 if ((i + 1) < self.min_samples_leaf) or ((n_samples - i - 1) < self.min_samples_leaf):
                     continue
-                
-                if sortted_feature[i + 1] <= sortted_feature[i] + self.EPSILON:
-                    continue
-
-                if self.min_samples_leaf < n_samples / max((self.n_split_grid - 1), 2):
-                    if (i + 1) / n_samples < (split_point + 1) / (self.n_split_grid + 1):
-                        continue
-                elif n_samples > 2 * self.min_samples_leaf:
-                    if (i + 1 - self.min_samples_leaf) / (n_samples - 2 * self.min_samples_leaf) < split_point / (self.n_split_grid - 1):
-                        continue
-                elif (i + 1) != self.min_samples_leaf:
-                    continue
 
-                split_point += 1
                 left_indice = sortted_indice[:(i + 1)]
                 if node_y[left_indice].std() == 0:
                     left_impurity = 0