0.32.2

Author: bartzbeielstein

pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "spotpython"
-version = "0.32.1"
+version = "0.32.2"
 authors = [
   { name="T. Bartz-Beielstein", email="tbb@bartzundbartz.de" }
 ]

src/spotpython/surrogate/kriging.py

@@ -469,34 +469,6 @@ def build_Psi(self) -> None:
             print("Building Psi failed. Error: %s, Type: %s", err, type(err))
             raise
 
-    def _kernel(self, X: np.ndarray, theta: np.ndarray, p: float) -> np.ndarray:
-        """
-        Computes the correlation matrix Psi using vectorized operations.
-
-        Args:
-            X (np.ndarray): Input data of shape (n_samples, n_features).
-            theta (np.ndarray): Theta parameters of shape (n_features,).
-            p (float): Power exponent.
-
-        Returns:
-            np.ndarray: The upper triangle of the correlation matrix Psi.
-        """
-        n_samples, n_features = X.shape
-        Psi = np.zeros((n_samples, n_samples), dtype=float)
-        # Calculate all pairwise differences:
-        # X_expanded_rows will have shape (n_samples, 1, n_features)
-        # X_expanded_cols will have shape (1, n_samples, n_features)
-        # diff will have shape (n_samples, n_samples, n_features)
-        diff = np.abs(X[:, np.newaxis, :] - X[np.newaxis, :, :]) ** p
-        # Apply theta and sum over features
-        # dist_matrix will have shape (n_samples, n_samples)
-        dist_matrix = np.sum(theta * diff, axis=2)
-        # Compute Psi using the exponential kernel
-        Psi = np.exp(-dist_matrix)
-        # Return only the upper triangle, as the matrix is symmetric
-        # and the diagonal will be handled later.
-        return np.triu(Psi, k=1)
-
     def likelihood(self, x: np.ndarray) -> Tuple[float, np.ndarray, np.ndarray]:
         """
         Computes the negative of the concentrated log-likelihood for a given set
@@ -541,14 +513,6 @@ def likelihood(self, x: np.ndarray) -> Tuple[float, np.ndarray, np.ndarray]:
         n = X.shape[0]
         one = np.ones(n)
 
-        # Build the correlation matrix Psi (modified in 0.31.0)
-        # theta = self.theta
-        # theta is in log scale, so transform it back:
-        # theta10 = 10.0**theta
-        # p = self.p_val
-        # Build correlation matrix (preparation for build_Psi())
-        # Psi_upper_triangle = self._kernel(X, theta10, p)
-
         Psi_upper_triangle = self.build_Psi()
 
         Psi = Psi_upper_triangle + Psi_upper_triangle.T + np.eye(n) + np.eye(n) * lambda_
@@ -655,16 +619,13 @@ def _pred(self, x: np.ndarray) -> float:
         y = self.y_.flatten()
 
         if (self.method == "regression") or (self.method == "reinterpolation"):
-            # theta = x[:-1]
             self.theta = self.logtheta_lambda_[: self.n_theta]
-            # lambda_ = x[-1]
             lambda_ = self.logtheta_lambda_[self.n_theta : self.n_theta + 1]
             # lambda is in log scale, so transform it back:
             lambda_ = 10.0**lambda_
             if self.optim_p:
                 self.p_val = self.logtheta_lambda_[self.n_theta + 1 : self.n_theta + 1 + self.n_p]
         elif self.method == "interpolation":
-            # theta = x
             self.theta = self.logtheta_lambda_[: self.n_theta]
             # use the original, untransformed eps:
             lambda_ = self.eps
@@ -688,17 +649,6 @@ def _pred(self, x: np.ndarray) -> float:
         resid_tilde = np.linalg.solve(U, resid)
         resid_tilde = np.linalg.solve(U.T, resid_tilde)
 
-        # Build psi (modified in 0.31.0)
-        # X = self.X_
-        # p = self.p_val
-        # theta = self.theta
-        # # theta is in log scale, so transform it back:
-        # theta10 = 10.0**theta
-        # psi = np.ones(n)
-        # for i in range(n):
-        #     dist_vec = np.abs(X[i, :] - x) ** p
-        #     psi[i] = np.exp(-np.sum(theta10 * dist_vec))
-
         psi = self.build_psi_vec(x)
 
         # Compute SigmaSqr and SSqr

src/spotpython/utils/metrics.py

@@ -30,7 +30,6 @@
 from scipy.stats import spearmanr
 
 
-
 def apk(actual, predicted, k=10):
     """
     Computes the average precision at k.
@@ -278,13 +277,14 @@ def calculate_xai_consistency_euclidean(attributions) -> float:
     print(result_xai)
     return result_xai
 
+
 def calculate_xai_consistency_spearman(attributions) -> float:
     """
     Calculates the consistency of XAI methods using Spearman rank correlation.
-    
+
     Args:
         attributions (np.ndarray): shape (n_methods, n_features)
-    
+
     Returns:
         float: Mean of upper triangle of Spearman correlation matrix (excluding diagonal)
     """
@@ -305,4 +305,4 @@ def calculate_xai_consistency_spearman(attributions) -> float:
 
     print("XAI Consistency (mean of upper triangle of Spearman correlation matrix):")
     print(upper_triangle_values.mean())
-    return upper_triangle_values.mean()
+    return upper_triangle_values.mean()