Merge pull request #273 from bmreiniger/270_cast_from_empty

Use np.empty/zeros dtype arg instead of astype'ing

optbinning/binning/binning.py

@@ -902,7 +902,7 @@ def _fit_optimizer(self, splits, n_nonevent, n_event):
         if len(n_nonevent) <= 1:
             self._status = "OPTIMAL"
             self._splits_optimal = splits
-            self._solution = np.zeros(len(splits)).astype(bool)
+            self._solution = np.zeros(len(splits), dtype=bool)
 
             if self.verbose:
                 logger.warning("Optimizer: {} bins after pre-binning."
@@ -1083,8 +1083,8 @@ def _compute_prebins(self, splits_prebinning, x, y0, y1, sw):
             indices = np.digitize(x, splits_prebinning, right=False)
             n_bins = n_splits + 1
 
-        n_nonevent = np.empty(n_bins).astype(np.int64)
-        n_event = np.empty(n_bins).astype(np.int64)
+        n_nonevent = np.empty(n_bins, dtype=np.int64)
+        n_event = np.empty(n_bins, dtype=np.int64)
 
         for i in range(n_bins):
             mask = (indices == i)

optbinning/binning/continuous_binning.py

@@ -905,11 +905,11 @@ def _compute_prebins(self, splits_prebinning, x, y, sw):
             indices = np.digitize(x, splits_prebinning, right=False)
             n_bins = n_splits + 1
 
-        n_records = np.empty(n_bins).astype(np.int64)
+        n_records = np.empty(n_bins, dtype=np.int64)
         sums = np.empty(n_bins)
         ssums = np.empty(n_bins)
         stds = np.zeros(n_bins)
-        n_zeros = np.empty(n_bins).astype(np.int64)
+        n_zeros = np.empty(n_bins, dtype=np.int64)
         min_t = np.full(n_bins, -np.inf)
         max_t = np.full(n_bins, np.inf)
 

optbinning/binning/cp.py

@@ -273,7 +273,7 @@ def solve(self):
             solution = np.array([self.solver_.BooleanValue(self._x[i, i])
                                  for i in range(self._n)]).astype(bool)
         else:
-            solution = np.zeros(self._n).astype(bool)
+            solution = np.zeros(self._n, dtype=bool)
             solution[-1] = True
 
         return status_name, solution

optbinning/binning/distributed/bsketch.py

@@ -159,8 +159,8 @@ def bins(self, splits):
         bins : tuple of arrays of size n_splits + 1.
         """
         n_bins = len(splits) + 1
-        bins_e = np.zeros(n_bins).astype(np.int64)
-        bins_ne = np.zeros(n_bins).astype(np.int64)
+        bins_e = np.zeros(n_bins, dtype=np.int64)
+        bins_ne = np.zeros(n_bins, dtype=np.int64)
 
         indices_e, count_e = _indices_count(
             self.sketch, self._sketch_e, splits)

optbinning/binning/ls.py

@@ -223,7 +223,7 @@ def solve(self):
             solution = np.array([self._x[i].value
                                  for i in range(self._n)]).astype(bool)
         else:
-            solution = np.zeros(self._n).astype(bool)
+            solution = np.zeros(self._n, dtype=bool)
             solution[-1] = True
 
         return status_name, solution

optbinning/binning/mip.py

@@ -199,7 +199,7 @@ def solve(self):
             else:
                 status_name = "UNKNOWN"
 
-            solution = np.zeros(self._n).astype(bool)
+            solution = np.zeros(self._n, dtype=bool)
             solution[-1] = True
 
         return status_name, solution

optbinning/binning/multiclass_binning.py

@@ -602,7 +602,7 @@ def _fit(self, x, y, check_input):
         time_postprocessing = time.perf_counter()
 
         if not len(splits):
-            n_event = np.empty(self._n_classes).astype(np.int64)
+            n_event = np.empty(self._n_classes, dtype=np.int64)
 
             for i, cl in enumerate(self._classes):
                 n_event[i] = target_info(y_clean, cl)[0]
@@ -671,7 +671,7 @@ def _fit_optimizer(self, splits, n_nonevent, n_event):
         if not len(n_nonevent):
             self._status = "OPTIMAL"
             self._splits_optimal = splits
-            self._solution = np.zeros(len(splits)).astype(bool)
+            self._solution = np.zeros(len(splits), dtype=bool)
 
             if self.verbose:
                 logger.warning("Optimizer: no bins after pre-binning.")
@@ -790,9 +790,9 @@ def _compute_prebins(self, splits_prebinning, x, y):
         indices = np.digitize(x, splits_prebinning, right=False)
 
         n_bins = n_splits + 1
-        n_nonevent = np.empty((n_bins, self._n_classes)).astype(np.int64)
-        n_event = np.empty((n_bins, self._n_classes)).astype(np.int64)
-        mask_remove = np.zeros(n_bins).astype(bool)
+        n_nonevent = np.empty((n_bins, self._n_classes), dtype=np.int64)
+        n_event = np.empty((n_bins, self._n_classes), dtype=np.int64)
+        mask_remove = np.zeros(n_bins, dtype=bool)
 
         for idx, cl in enumerate(self._classes):
             y1 = (y == cl)

optbinning/binning/multidimensional/mip_2d.py

@@ -109,7 +109,7 @@ def solve(self):
             else:
                 status_name = "UNKNOWN"
 
-            solution = np.zeros(self._n_rectangles).astype(bool)
+            solution = np.zeros(self._n_rectangles, dtype=bool)
 
         return status_name, solution
 

optbinning/binning/uncertainty/binning_scenarios.py

@@ -678,9 +678,9 @@ def _compute_prebins(self, splits_prebinning, x, y):
             return splits_prebinning, np.array([]), np.array([])
 
         n_bins = n_splits + 1
-        n_nonevent = np.empty((n_bins, self._n_scenarios)).astype(np.int64)
-        n_event = np.empty((n_bins, self._n_scenarios)).astype(np.int64)
-        mask_remove = np.zeros(n_bins).astype(bool)
+        n_nonevent = np.empty((n_bins, self._n_scenarios), dtype=np.int64)
+        n_event = np.empty((n_bins, self._n_scenarios), dtype=np.int64)
+        mask_remove = np.zeros(n_bins, dtype=bool)
 
         for s in range(self._n_scenarios):
             y0 = (y[s] == 0)
@@ -733,7 +733,7 @@ def _fit_optimizer(self, splits, n_nonevent, n_event, weights):
         if not len(n_nonevent):
             self._status = "OPTIMAL"
             self._splits_optimal = splits
-            self._solution = np.zeros(len(splits)).astype(bool)
+            self._solution = np.zeros(len(splits), dtype=bool)
 
             if self.verbose:
                 logger.warning("Optimizer: no bins after pre-binning.")

optbinning/scorecard/monitoring.py

@@ -78,7 +78,7 @@ def print_psi_report(df_psi):
     n_bins = len(splits) + 1
     indices = np.digitize(psi, splits, right=True)
 
-    psi_bins = np.empty(n_bins).astype(np.int64)
+    psi_bins = np.empty(n_bins, dtype=np.int64)
     for i in range(n_bins):
         mask = (indices == i)
         psi_bins[i] = len(psi[mask])
@@ -109,7 +109,7 @@ def print_tests_report(df_tests):
     n_bins = len(splits) + 1
     indices = np.digitize(pvalues, splits, right=True)
 
-    pvalue_bins = np.empty(n_bins).astype(np.int64)
+    pvalue_bins = np.empty(n_bins, dtype=np.int64)
     for i in range(n_bins):
         mask = (indices == i)
         pvalue_bins[i] = len(pvalues[mask])
@@ -501,10 +501,10 @@ def _fit_system(self, X_actual, y_actual, X_expected, y_expected):
         indices_e = np.digitize(score_expected, splits, right=True)
 
         if self._target_dtype == "binary":
-            n_nonevent_a = np.empty(n_bins).astype(np.int64)
-            n_event_a = np.empty(n_bins).astype(np.int64)
-            n_nonevent_e = np.empty(n_bins).astype(np.int64)
-            n_event_e = np.empty(n_bins).astype(np.int64)
+            n_nonevent_a = np.empty(n_bins, dtype=np.int64)
+            n_event_a = np.empty(n_bins, dtype=np.int64)
+            n_nonevent_e = np.empty(n_bins, dtype=np.int64)
+            n_event_e = np.empty(n_bins, dtype=np.int64)
 
             y0_a = (y_actual == 0)
             y1_a = ~ y0_a
@@ -524,8 +524,8 @@ def _fit_system(self, X_actual, y_actual, X_expected, y_expected):
             n_records_a = n_nonevent_a + n_event_a
             n_records_e = n_nonevent_e + n_event_e
         else:
-            n_records_a = np.empty(n_bins).astype(np.int64)
-            n_records_e = np.empty(n_bins).astype(np.int64)
+            n_records_a = np.empty(n_bins, dtype=np.int64)
+            n_records_e = np.empty(n_bins, dtype=np.int64)
             mean_a = np.empty(n_bins)
             mean_e = np.empty(n_bins)
             std_a = np.empty(n_bins)
@@ -784,8 +784,8 @@ def _fit_variables(self, X_actual, X_expected):
 
             n_bins = te.max() + 1
 
-            n_records_a = np.empty(n_bins).astype(np.int64)
-            n_records_e = np.empty(n_bins).astype(np.int64)
+            n_records_a = np.empty(n_bins, dtype=np.int64)
+            n_records_e = np.empty(n_bins, dtype=np.int64)
 
             for i in range(n_bins):
                 n_records_a[i] = np.count_nonzero(ta == i)