physbo 2.0.0__cp310-cp310-macosx_12_0_arm64.whl

physbo/gp/lik/gauss.py

@@ -0,0 +1,179 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import numpy as np
+
+
+class gauss:
+    """Gaussian likelihood function"""
+
+    def __init__(self, std=1, max_params=1e6, min_params=1e-6):
+        """
+
+        Parameters
+        ----------
+        std: numpy.ndarray or float
+            standard deviation.
+        max_params: float
+            The maximum value of the parameter.
+            If the parameter is greater than this value, it will be replaced by this value.
+        min_params: float
+            The minimum value of the parameter.
+            If the parameter is less than this value, it will be replaced by this value.
+        """
+        self.min_params = np.log(min_params)
+        self.max_params = np.log(max_params)
+        self.num_params = 1
+        self.std = std
+        self.params = np.log(std)
+        self.set_params(self.params)
+
+    def supp_params(self, params=None):
+        """
+        Set maximum (minimum) values for parameters when the parameter is greater(less) than this value.
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            Parameters for optimization.
+            Array of real elements of size (n,), where ‘n’ is the number of independent variables.
+        Returns
+        -------
+
+        """
+        if params is None:
+            params = np.copy(params)
+
+        if params > self.max_params:
+            params = self.max_params
+
+        if params < self.min_params:
+            params = self.min_params
+
+        return params
+
+    def trans_params(self, params=None):
+        """
+        Get exp[params].
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            Parameters for optimization.
+            Array of real elements of size (n,), where ‘n’ is the number of independent variables.
+
+        Returns
+        -------
+        std: numpy.ndarray
+        """
+        if params is None:
+            params = np.copy(self.params)
+
+        std = np.exp(params)
+        return std
+
+    def get_params_bound(self):
+        """
+        Get boundary array.
+
+        Returns
+        -------
+        bound: list
+            A num_params-dimensional array with the tuple (min_params, max_params).
+        """
+        bound = [(self.min_params, self.max_params) for i in range(0, self.num_params)]
+        return bound
+
+    def get_cov(self, num_data, params=None):
+        """
+        Get a covariance matrix
+
+        Parameters
+        ----------
+        num_data: int
+        params: numpy.ndarray
+            Parameters for optimization.
+            Array of real elements of size (n,), where ‘n’ is the number of independent variables.
+
+        Returns
+        -------
+        numpy.ndarray
+            Diagonal element matrix of exp(2.0*params)
+        """
+        std = self.trans_params(params)
+        var = std**2
+        return var * np.identity(num_data)
+
+    def get_grad(self, num_data, params=None):
+        """
+        Get a gradient matrix
+
+        Parameters
+        ----------
+        num_data: int
+        params: numpy.ndarray
+            Parameters for optimization.
+            Array of real elements of size (n,), where ‘n’ is the number of independent variables.
+
+        Returns
+        -------
+        numpy.ndarray
+            Diagonal element matrix of 2.0 * exp(2.0*params)
+        """
+        std = self.trans_params(params)
+        var = std**2
+        return var * np.identity(num_data) * 2
+
+    def set_params(self, params):
+        """
+        Set parameters.
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            Parameters for optimization.
+            Array of real elements of size (n,), where ‘n’ is the number of independent variables.
+
+        Returns
+        -------
+
+        """
+        self.params = self.supp_params(params)
+        self.std = self.trans_params(params)
+
+    def get_cand_params(self, t):
+        """
+        Getting candidate parameters.
+
+        Parameters
+        ----------
+        t:  numpy.ndarray
+            N dimensional array. The negative energy of each search candidate (value of the objective function to be optimized).
+
+        Returns
+        -------
+        numpy.ndarray
+            log[ standard deviation of t] - log 10.0
+        """
+        return np.log(np.std(t) / 10)
+
+    # [TODO] Check: This function seems not to be used.
+    def sampling(self, fmean):
+        """
+        Sampling by adding noise
+
+        Parameters
+        ----------
+        fmean: numpy.ndarray
+
+        Returns
+        -------
+
+        """
+        num_data = fmean.shape[0]
+        eps = self.std * np.random.randn(num_data)
+        return fmean + eps

physbo/gp/mean/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from .zero import zero
+from .const import const

physbo/gp/mean/const.py

@@ -0,0 +1,150 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import numpy as np
+
+
+class const:
+    """constant"""
+
+    def __init__(self, params=None, max_params=1e12, min_params=-1e12):
+        """
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            Parameters
+        max_params: float
+            Threshold value for specifying the maximum value of the parameter
+        min_params: float
+            Threshold value for specifying the minimum value of the parameter
+
+        """
+        self.max_params = max_params
+        self.min_params = min_params
+        self.init_params(params)
+        self.num_params = 1
+
+    def supp_params(self, params):
+        """
+        Setting maximum and minimum value of parameters.
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+            numpy.ndarray
+        """
+        if params > self.max_params:
+            params = self.max_params
+
+        if params < self.min_params:
+            params = self.min_params
+
+        return params
+
+    def get_params_bound(self):
+        """
+        Getting the boundary list for parameters
+
+        Returns
+        -------
+        bound: list
+            num_params array with the tupple (min_param, max_params)
+
+        """
+        bound = [(self.min_params, self.max_params) for i in range(0, self.num_params)]
+        return bound
+
+    def get_mean(self, num_data, params=None):
+        """
+
+        Parameters
+        ----------
+        num_data: int
+            total number of data
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+            numpy.ndarray
+        """
+        if params is None:
+            params = np.copy(self.params)
+        return params * np.ones(num_data)
+
+    def get_grad(self, num_data, params=None):
+        """
+        Returning a new array of (num_data), filled with ones.
+
+        Parameters
+        ----------
+        num_data: int
+            total number of data
+        params: object
+            not used
+
+        Returns
+        -------
+            numpy.ndarray
+        """
+        return np.ones(num_data)
+
+    def set_params(self, params):
+        """
+        Setting parameters defined in const class.
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+            numpy.ndarray
+        """
+        self.params = params
+
+    def init_params(self, params):
+        """
+        Initializing parameters
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+        params: numpy.ndarray
+            initialized parameters
+        """
+        if params is None:
+            self.params = 0
+        else:
+            self.params = self.supp_params(params)
+
+    def get_cand_params(self, t):
+        """
+        Getting the median array of candidates.
+
+        Parameters
+        ----------
+        t: array_like
+            Input array or object that can be converted to an array
+
+        Returns
+        -------
+        median: numpy.ndarray
+            A new array holding the result.
+
+        """
+        return np.median(t)

physbo/gp/mean/zero.py

@@ -0,0 +1,66 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import numpy as np
+
+
+class zero:
+    """zero"""
+
+    def __init__(self):
+        self.num_params = 0
+        self.params = np.array([])
+
+    def get_mean(self, num_data, params=None):
+        """
+        Returning numpy.zeros(num_data)
+
+        Parameters
+        ----------
+        num_data: int
+            dimension of numpy.zeros
+        params: object
+            not used
+
+        Returns
+        -------
+            numpy.ndarray
+
+        """
+        return np.zeros(num_data)
+
+    def get_grad(self, num_data, params=None):
+        """
+        Returning empty numpy.ndarray
+
+        Parameters
+        ----------
+        num_data: int
+            not used
+        params: object
+            not used
+
+        Returns
+        -------
+            numpy.ndarray
+
+        """
+        return np.array([])
+
+    def set_params(self, params):
+        """
+        Not defined
+
+        Parameters
+        ----------
+        params
+
+        Returns
+        -------
+
+        """
+        pass

physbo/gp/predictor.py

@@ -0,0 +1,170 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import physbo.predictor
+
+
+class predictor(physbo.predictor.base_predictor):
+    """predictor"""
+
+    def __init__(self, config, model=None):
+        """
+
+        Parameters
+        ----------
+        config: physbo.misc.set_config
+            configuration
+        model: physbo.gp.core.model
+        """
+        super(predictor, self).__init__(config, model)
+
+    def fit(self, training, num_basis=None):
+        """
+        Fitting model to training dataset
+
+        Parameters
+        ----------
+        training: physbo.variable
+            dataset for training
+        num_basis: int
+            the number of basis (default: self.config.predict.num_basis)
+        """
+        if self.model.prior.cov.num_dim is None:
+            self.model.prior.cov.num_dim = training.X.shape[1]
+        self.model.fit(training.X, training.t, self.config)
+        self.delete_stats()
+
+    def get_basis(self, *args, **kwds):
+        """
+
+        Parameters
+        ----------
+        args
+        kwds
+
+        Returns
+        -------
+
+        """
+        pass
+
+    def get_post_params(self, *args, **kwds):
+        """
+
+        Parameters
+        ----------
+        args
+        kwds
+
+        Returns
+        -------
+
+        """
+        pass
+
+    def update(self, training, test):
+        self.prepare(training)
+
+    def prepare(self, training):
+        """
+        Initializing model by using training data set
+
+        Parameters
+        ----------
+        training: physbo.variable
+            dataset for training
+
+        """
+        self.model.prepare(training.X, training.t)
+
+    def delete_stats(self):
+        self.model.stats = None
+
+    def get_post_fmean(self, training, test):
+        """
+        Calculating posterior mean value of model
+
+        Parameters
+        ----------
+        training: physbo.variable
+            training dataset. If already trained, the model does not use this.
+        test: physbo.variable
+            inputs
+
+        Returns
+        -------
+        numpy.ndarray
+
+        """
+        if self.model.stats is None:
+            self.prepare(training)
+        return self.model.get_post_fmean(training.X, test.X)
+
+    def get_post_fcov(self, training, test, diag=True):
+        """
+        Calculating posterior variance-covariance matrix of model
+
+        Parameters
+        ----------
+        training: physbo.variable
+            training dataset. If already trained, the model does not use this.
+        test: physbo.variable
+            inputs
+        diag: bool
+            Diagonlization flag in physbo.exact.get_post_fcov function.
+        Returns
+        -------
+        numpy.ndarray
+
+        """
+        if self.model.stats is None:
+            self.prepare(training)
+        return self.model.get_post_fcov(training.X, test.X, diag=diag)
+
+    def get_post_samples(self, training, test, alpha=1):
+        """
+        Drawing samples of mean values of model
+
+        Parameters
+        ----------
+        training: physbo.variable
+            training dataset. If already trained, the model does not use this.
+        test: physbo.variable
+            inputs (not used)
+        alpha: float
+            tuning parameter of the covariance by multiplying alpha**2 for np.random.multivariate_normal.
+        Returns
+        -------
+        numpy.ndarray
+
+        """
+        if self.model.stats is None:
+            self.prepare(training)
+        return self.model.post_sampling(training.X, test.X, alpha=alpha)
+
+    def get_predict_samples(self, training, test, N=1):
+        """
+        Drawing samples of values of model
+
+        Parameters
+        ----------
+        training: physbo.variable
+            training dataset. If already trained, the model does not use this.
+        test: physbo.variable
+            inputs
+        N: int
+            number of samples
+            (default: 1)
+
+        Returns
+        -------
+        numpy.ndarray (N x len(test))
+
+        """
+        if self.model.stats is None:
+            self.prepare(training)
+        return self.model.predict_sampling(training.X, test.X, N=N)

physbo/misc/__init__.py

@@ -0,0 +1,15 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+from .centering import centering
+from .gauss_elim import gauss_elim
+from .set_config import set_config
+from ._src.diagAB import diagAB_64 as diagAB
+from ._src.traceAB import traceAB2_64 as traceAB2
+from ._src.traceAB import traceAB3_64 as traceAB3
+from ._src.cholupdate import cholupdate64 as cholupdate
+from ._src.logsumexp import logsumexp64

physbo/misc/_src/__init__.py

@@ -0,0 +1 @@
+

physbo/misc/centering.py

@@ -0,0 +1,28 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import numpy as np
+
+
+def centering(X):
+    """
+    Normalize the mean and standard deviation along the each column of X to 0 and 1, respectively
+
+    Parameters
+    ----------
+    X: numpy array
+        N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+
+    Returns
+    -------
+    X_normalized: numpy array
+        normalized N x d dimensional matrix.
+    """
+    stdX = np.std(X, 0)
+    index = np.where(stdX != 0)
+    X_normalized = (X[:, index[0]] - np.mean(X[:, index[0]], 0)) / stdX[index[0]]
+    return X_normalized

physbo/misc/gauss_elim.py

@@ -0,0 +1,35 @@
+# SPDX-License-Identifier: MPL-2.0
+# Copyright (C) 2020- The University of Tokyo
+#
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+import numpy as np
+import scipy
+
+
+def gauss_elim(U, t):
+    """
+    Calculate alpha using scipy.linalg.solve_triangular.
+    alpha = (U^T U)^-1 t = U^-1 [(U^T)-1 t]
+
+    Parameters
+    ----------
+    U: (M, M) array_like
+    A triangular matrix
+    t: (M,) or (M, N) array_like
+
+    Returns
+    -------
+    alpha: numpy.ndarray
+    Solution to the system L^T alpha = t. Shape of return matches t.
+    """
+    alpha = scipy.linalg.solve_triangular(
+        U.transpose(), t, lower=True, overwrite_b=False, check_finite=False
+    )
+
+    alpha = scipy.linalg.solve_triangular(
+        U, alpha, lower=False, overwrite_b=False, check_finite=False
+    )
+    return alpha