physbo 2.0.2__tar.gz → 2.2.0__tar.gz

{physbo-2.0.2 → physbo-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: physbo
-Version: 2.0.2
+Version: 2.2.0
 Summary: optimization tool for PHYSics based on Bayesian Optimization
 Home-page: https://github.com/issp-center-dev/PHYSBO
 Author: PHYSBO developers

{physbo-2.0.2 → physbo-2.2.0}/physbo/__init__.py

@@ -14,4 +14,4 @@ from . import predictor
 from .predictor import base_predictor
 from .variable import variable
 
-__version__ = "2.0.2"
+__version__ = "2.2.0"

{physbo-2.0.2 → physbo-2.2.0}/physbo/blm/core/model.py

@@ -218,13 +218,15 @@ class model:
         Returns
         =======
         numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in X.
 
         See also
         ========
         physbo.blm.inf.exact.get_post_fcov
         """
         if self.method == "exact":
-            fcov = inf.exact.get_post_fcov(self, X, Psi, diag=True)
+            fcov = inf.exact.get_post_fcov(self, X, Psi, diag=diag)
         else:
             pass
         return fcov

{physbo-2.0.2 → physbo-2.2.0}/physbo/blm/inf/exact.py

@@ -170,6 +170,8 @@ def get_post_fcov(blm, X, Psi=None, diag=True):
     Returns
     =======
     numpy.ndarray
+        Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+        where num_points is the number of points in X.
     """
     if Psi is None:
         Psi = blm.lik.linear.basis.get_basis(X)

{physbo-2.0.2 → physbo-2.2.0}/physbo/blm/predictor.py

@@ -101,12 +101,14 @@ class predictor(physbo.predictor.base_predictor):
         Returns
         =======
         numpy.ndarray
+            Returned shape is (num_points),
+            where num_points is the number of points in test.
         """
         if self.blm.stats is None:
             self.prepare(training)
         return self.blm.get_post_fmean(test.X, test.Z)
 
-    def get_post_fcov(self, training, test):
+    def get_post_fcov(self, training, test, diag=True):
         """
         calculates posterior variance-covariance matrix of model
 
@@ -116,14 +118,17 @@ class predictor(physbo.predictor.base_predictor):
             training dataset. If already trained, the model does not use this.
         test: physbo.variable
             inputs
-
+        diag: bool
+            If true, only variances (diagonal elements) are returned.
         Returns
         =======
         numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in test.
         """
         if self.blm.stats is None:
             self.prepare(training)
-        return self.blm.get_post_fcov(test.X, test.Z)
+        return self.blm.get_post_fcov(test.X, test.Z, diag)
 
     def get_post_params(self, training, test):
         """

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/__init__.py

@@ -11,5 +11,6 @@ from . import lik
 
 from .core import prior
 from .core import model
+from .core import sfs
 from .core import learning
 from .predictor import predictor

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/core/__init__.py

@@ -7,5 +7,6 @@
 
 from .prior import prior
 from .model import model
+from .model import sfs
 
 # from predictor import predictor

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/core/model.py

@@ -11,7 +11,7 @@ from physbo import blm
 from physbo.gp import inf
 from physbo.gp.core import learning
 from physbo.gp.core.prior import prior
-
+from physbo.misc import set_config
 
 class model:
     def __init__(self, lik, mean, cov, inf="exact"):
@@ -269,11 +269,13 @@ class model:
         params: numpy.ndarray
             Parameters
         diag: bool
-            If X is the diagonalization matrix, true.
+            If true, only variances (diagonal elements) are returned.
 
         Returns
         -------
-        physbo.gp.inf.exact.get_post_fcov
+        numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in X.
 
         """
         if params is None:
@@ -308,7 +310,7 @@ class model:
 
         fmean = self.get_post_fmean(X, Z, params=None)
         fcov = self.get_post_fcov(X, Z, params=None, diag=False)
-        return np.random.multivariate_normal(fmean, fcov * alpha**2, N)
+        return np.random.multivariate_normal(fmean, fcov * alpha ** 2, N)
 
     def predict_sampling(self, X, Z, params=None, N=1):
         """
@@ -418,3 +420,81 @@ class model:
             params = bfgs.run(X, t)
 
         self.set_params(params)
+
+class sfs(model):
+
+    def __init__(self, lik, mean, cov, inf="exact",config=None):
+        super().__init__(lik, mean, cov, inf)
+
+        self.config = config
+
+    def prepare(self, X, t, params=None):
+        return super().prepare(X, t, params)
+
+    def fit(self, X, t):
+        """
+        Fitting function (update parameters)
+
+        Parameters
+        ----------
+        X: numpy.ndarray
+            N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+
+        t:  numpy.ndarray
+            N dimensional array.
+            The negative energy of each search candidate (value of the objective function to be optimized).
+        config: physbo.misc.set_config object
+
+        """
+        #config = set_config()
+        method = self.config.learning.method
+
+        if method == "adam":
+            adam = learning.adam(self, self.config)
+            params = adam.run(X, t)
+
+        if method in ("bfgs", "batch"):
+            bfgs = learning.batch(self, self.config)
+            params = bfgs.run(X, t)
+
+        self.set_params(params)
+
+        self.prepare(X, t, params=None)
+
+        self.xtrain = X
+    
+    def get_post_fmean(self, X, Z, params=None):
+        return super().get_post_fmean(X, Z, params)
+
+    def predict(self, Z, params=None):
+        """
+        Calculating posterior mean of model (function)
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            inputs
+        Z: numpy.ndarray
+            feature maps
+        params: numpy.ndarray
+            Parameters
+        See also
+        ========
+        physbo.gp.inf.exact.get_post_fmean
+        """
+
+        if params is None:
+            params = np.copy(self.params)
+
+        if self.inf == "exact":
+            post_fmu = inf.exact.get_post_fmean(self, self.xtrain, Z, params)
+
+        return post_fmu
+    
+    def get_params(self,deep=True):
+
+        mean = self.prior.mean
+        cov = self.prior.cov
+        config = self.config
+
+        return {"lik":self.lik,"mean":mean,"cov":cov,"config":config}

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/core/prior.py

@@ -19,7 +19,7 @@ class prior:
         ----------
         mean: numpy.ndarray
             mean values of prior
-        cov: numpy.ndarray
+        cov: physbo.gp.cov.gauss
             covariance matrix of priors
         """
         self.mean = mean
@@ -94,10 +94,13 @@ class prior:
         params: numpy.ndarray
            Parameters.
         diag: bool
-            If X is the diagonalization matrix, true.
+            If true, only variances (diagonal elements) are returned.
+
         Returns
         -------
         numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in X.
         """
         if params is None:
             params = np.copy(self.params)

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/cov/gauss.py

@@ -149,12 +149,14 @@ class gauss:
             Parameters
 
         diag: bool
-            If X is the diagonalization matrix, true.
+            If true, only variances (diagonal elements) are returned.
 
         Returns
         -------
         G: numpy.ndarray
             covariant matrix
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in X.
         """
         params, width, scale = self.prepare(params)
         scale2 = scale**2

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/inf/exact.py

@@ -203,10 +203,13 @@ def get_post_fcov(gp, X, Z, params=None, diag=True):
     params: numpy.ndarray
         Parameters.
     diag: bool
-        If X is the diagonalization matrix, true.
+        If true, only variances (diagonal elements) are returned.
+
     Returns
     -------
         numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in X.
     """
 
     lik_params, prior_params = gp.decomp_params(params)

{physbo-2.0.2 → physbo-2.2.0}/physbo/gp/predictor.py

@@ -115,10 +115,13 @@ class predictor(physbo.predictor.base_predictor):
         test: physbo.variable
             inputs
         diag: bool
-            Diagonlization flag in physbo.exact.get_post_fcov function.
+            If true, only variances (diagonal elements) are returned.
+
         Returns
         -------
         numpy.ndarray
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false,
+            where num_points is the number of points in test.
 
         """
         if self.model.stats is None:

{physbo-2.0.2 → physbo-2.2.0}/physbo/search/discrete/policy.py

@@ -348,7 +348,21 @@ class policy:
         print("         before calling {}.".format(method_name))
 
     def get_post_fmean(self, xs):
-        """Calculate mean value of predictor (post distribution)"""
+        """
+        Calculate mean value of predictor (post distribution)
+
+        Parameters
+        ----------
+        xs: physbo.variable or np.ndarray
+            input parameters to calculate mean value
+            shape is (num_points, num_parameters)
+
+        Returns
+        -------
+        fmean: numpy.ndarray
+            Mean value of the post distribution.
+            Returned shape is (num_points).
+        """
         X = self._make_variable_X(xs)
         if self.predictor is None:
             self._warn_no_predictor("get_post_fmean()")
@@ -360,18 +374,34 @@ class policy:
             self._update_predictor()
             return self.predictor.get_post_fmean(self.training, X)
 
-    def get_post_fcov(self, xs):
-        """Calculate covariance of predictor (post distribution)"""
+    def get_post_fcov(self, xs, diag=True):
+        """
+        Calculate covariance of predictor (post distribution)
+
+        Parameters
+        ----------
+        xs: physbo.variable or np.ndarray
+            input parameters to calculate covariance
+            shape is (num_points, num_parameters)
+        diag: bool
+            If true, only variances (diagonal elements) are returned.
+
+        Returns
+        -------
+        fcov: numpy.ndarray
+            Covariance matrix of the post distribution.
+            Returned shape is (num_points) if diag=true, (num_points, num_points) if diag=false.
+        """
         X = self._make_variable_X(xs)
         if self.predictor is None:
             self._warn_no_predictor("get_post_fcov()")
             predictor = gp_predictor(self.config)
             predictor.fit(self.training, 0)
             predictor.prepare(self.training)
-            return predictor.get_post_fcov(self.training, X)
+            return predictor.get_post_fcov(self.training, X, diag)
         else:
             self._update_predictor()
-            return self.predictor.get_post_fcov(self.training, X)
+            return self.predictor.get_post_fcov(self.training, X, diag)
 
     def get_score(
         self,

{physbo-2.0.2 → physbo-2.2.0}/physbo/search/discrete_multi/policy.py

@@ -294,6 +294,23 @@ class policy(discrete.policy):
         return np.array(chosen_actions)
 
     def get_post_fmean(self, xs):
+        """
+        Calculate mean value of predictors (post distribution)
+
+        Parameters
+        ----------
+        xs: physbo.variable or np.ndarray
+            input parameters to calculate covariance
+            shape is (num_points, num_parameters)
+        diag: bool
+            If true, only variances (diagonal elements) are returned.
+
+        Returns
+        -------
+        fcov: numpy.ndarray
+            Covariance matrix of the post distribution.
+            Returned shape is (num_points, num_objectives).
+        """
         if self.predictor_list == [None] * self.num_objectives:
             self._warn_no_predictor("get_post_fmean()")
             predictor_list = []
@@ -312,7 +329,24 @@ class policy(discrete.policy):
         ]
         return np.array(fmean).T
 
-    def get_post_fcov(self, xs):
+    def get_post_fcov(self, xs, diag=True):
+        """
+        Calculate covariance of predictors (post distribution)
+
+        Parameters
+        ----------
+        xs: physbo.variable or np.ndarray
+            input parameters to calculate covariance
+            shape is (num_points, num_parameters)
+        diag: bool
+            If true, only variances (diagonal elements) are returned.
+
+        Returns
+        -------
+        fcov: numpy.ndarray
+            Covariance matrix of the post distribution.
+            Returned shape is (num_points, num_objectives) if diag=true, (num_points, num_points, num_objectives) if diag=false.
+        """
         if self.predictor_list == [None] * self.num_objectives:
             self._warn_no_predictor("get_post_fcov()")
             predictor_list = []
@@ -326,10 +360,14 @@ class policy(discrete.policy):
             predictor_list = self.predictor_list[:]
         X = self._make_variable_X(xs)
         fcov = [
-            predictor.get_post_fcov(training, X)
+            predictor.get_post_fcov(training, X, diag)
             for predictor, training in zip(predictor_list, self.training_list)
         ]
-        return np.array(fcov).T
+        arr = np.array(fcov)
+        if diag:
+            return arr.T
+        else:
+            return np.einsum("nij->ijn", arr)
 
     def get_score(
         self,

{physbo-2.0.2 → physbo-2.2.0}/physbo/search/pareto.py

@@ -6,7 +6,7 @@
 # file, You can obtain one at https://mozilla.org/MPL/2.0/.
 
 import numpy as np
-
+import time
 
 class Rectangles(object):
     def __init__(self, n_dim, dtype):
@@ -156,7 +156,7 @@ class Pareto(object):
         self.cells.add(lb_idx, ub_idx)
 
     def __included_in_non_dom_region(self, p):
-        return np.all([np.any(pf <= p) for pf in self.front])
+        return np.all(np.any(self.front <= p, axis=1)) # revised on 2025/03/25, vectorized with np.any
 
     def __divide_using_binary_search(self):
         front = np.r_[
@@ -165,17 +165,23 @@ class Pareto(object):
             np.full((1, self.num_objectives), np.inf),
         ]
 
-        # Pareto front indices when sorted on each dimension's front value in ascending order.
-        # (indices start from 1)
-        # Index 0 means anti-ideal value, index `self.front.shape[0] + 1` means ideal point.
+        # Pareto front indices sorted in each dimension
         front_idx = np.r_[
             np.zeros((1, self.num_objectives), dtype=int),
             np.argsort(self.front, axis=0) + 1,
             np.full((1, self.num_objectives), self.front.shape[0] + 1, dtype=int),
         ]
 
+        print("front_idx shape", front_idx.shape)
+
         rect_candidates = [[np.copy(front_idx[0]), np.copy(front_idx[-1])]]
 
+        call_time = 0
+
+        start_time = time.time()
+
+        # modified on 2025/03/25, optimized checking of non-dominated region
+
         while rect_candidates:
             rect = rect_candidates.pop()
 
@@ -184,23 +190,38 @@ class Pareto(object):
             lb = [front[lb_idx[d], d] for d in range(self.num_objectives)]
             ub = [front[ub_idx[d], d] for d in range(self.num_objectives)]
 
+            # first check if lb is in the non-dominated region, if so, add it to the cells
             if self.__included_in_non_dom_region(lb):
                 self.cells.add([lb_idx], [ub_idx])
+                call_time += 1
+                continue
+
+            # when lb is not in the non-dominated region, check if ub is in the non-dominated region
+            # if ub is in the non-dominated region, it means that the whole rectangle is in the dominated region
+            if not self.__included_in_non_dom_region(ub):
+                call_time += 1
+                continue
+
+            # only when lb is not in the non-dominated region and ub is in the non-dominated region,
+            # we need to divide the rectangle into two sub-rectangles
+
+            rect_sizes = rect[1] - rect[0]
+            if np.any(rect_sizes > 1):
+                div_dim = np.argmax(rect_sizes)
+                div_point = rect[0][div_dim] + int(round(rect_sizes[div_dim] / 2.0))
+
+                # Left sub-rectangle
+                left_ub_idx = np.copy(rect[1])
+                left_ub_idx[div_dim] = div_point
+                rect_candidates.append([np.copy(rect[0]), left_ub_idx])
 
-            elif self.__included_in_non_dom_region(ub):
-                rect_sizes = rect[1] - rect[0]
+                # Right sub-rectangle
+                right_lb_idx = np.copy(rect[0])
+                right_lb_idx[div_dim] = div_point
+                rect_candidates.append([right_lb_idx, np.copy(rect[1])])
 
-                # divide rectangle by the dimension with largest size
-                if np.any(rect_sizes > 1):
-                    div_dim = np.argmax(rect_sizes)
-                    div_point = rect[0][div_dim] + int(round(rect_sizes[div_dim] / 2.0))
+        end_time = time.time()
 
-                    # add divided left rectangle
-                    left_ub_idx = np.copy(rect[1])
-                    left_ub_idx[div_dim] = div_point
-                    rect_candidates.append([np.copy(rect[0]), left_ub_idx])
+        print("Execution time:", end_time - start_time)
 
-                    # add divided right rectangle
-                    right_lb_idx = np.copy(rect[0])
-                    right_lb_idx[div_dim] = div_point
-                    rect_candidates.append([right_lb_idx, np.copy(rect[1])])
+        print("call_time", call_time)

{physbo-2.0.2 → physbo-2.2.0}/physbo.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: physbo
-Version: 2.0.2
+Version: 2.2.0
 Summary: optimization tool for PHYSics based on Bayesian Optimization
 Home-page: https://github.com/issp-center-dev/PHYSBO
 Author: PHYSBO developers

{physbo-2.0.2 → physbo-2.2.0}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = physbo
-version = 2.0.2
+version = 2.2.0
 description = optimization tool for PHYSics based on Bayesian Optimization
 long_description = file: README.md
 long_description_content_type = text/markdown