physbo 2.0.0__cp310-cp310-macosx_12_0_arm64.whl

physbo/gp/cov/gauss.py

@@ -0,0 +1,393 @@
+# 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/.
+
+# -*- coding:utf-8 -*-
+import numpy as np
+from scipy import spatial
+from ._src.enhance_gauss import grad_width64
+
+
+class gauss:
+    """gaussian kernel"""
+
+    def __init__(
+        self,
+        num_dim,
+        width=3,
+        scale=1,
+        ard=False,
+        max_width=1e6,
+        min_width=1e-6,
+        max_scale=1e6,
+        min_scale=1e-6,
+    ):
+        """
+
+        Parameters
+        ----------
+        num_dim: int
+        width: float
+        scale: float
+        ard: bool
+            flag to use Automatic Relevance Determination (ARD).
+        max_width: float
+            Maximum value of width
+        min_width: float
+            Minimum value of width
+        max_scale: float
+            Maximum value of scale
+        min_scale: float
+            Minimum value of scale
+        """
+        self.ard = ard
+        self.num_dim = num_dim
+        self.scale = scale
+        self.max_ln_width = np.log(max_width)
+        self.min_ln_width = np.log(min_width)
+        self.max_ln_scale = np.log(max_scale)
+        self.min_ln_scale = np.log(min_scale)
+
+        if self.ard:
+            # with ARD
+            self.num_params = num_dim + 1
+            if isinstance(width, np.ndarray) and len(width) == self.num_dim:
+                self.width = width
+            else:
+                self.width = width * np.ones(self.num_dim)
+        else:
+            # without ARD
+            self.width = width
+            self.num_params = 2
+
+        params = self.cat_params(self.width, self.scale)
+        self.set_params(params)
+
+    def print_params(self):
+        """
+        show the current kernel parameters
+
+        """
+
+        print(" Parameters of Gaussian kernel \n ")
+        print(" width  = ", +self.width)
+        print(" scale  = ", +self.scale)
+        print(" scale2 = ", +self.scale**2)
+        print(" \n")
+
+    def prepare(self, params=None):
+        """
+        Setting parameters
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+        params: numpy.ndarray
+        width: int
+        scale: int
+
+        """
+        if params is None:
+            params = self.params
+            width = self.width
+            scale = self.scale
+        else:
+            params = self.supp_params(params)
+            width, scale = self.decomp_params(params)
+
+        return params, width, scale
+
+    def get_grad(self, X, params=None):
+        """
+        Getting gradiant values of X
+
+        Parameters
+        ----------
+        X: numpy.ndarray
+            N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+
+        params: numpy.ndarray
+
+        Returns
+        -------
+        grad: numpy.ndarray
+
+        """
+        num_data = X.shape[0]
+        params, width, scale = self.prepare(params)
+        G = self.get_cov(X, params=params)
+
+        grad = np.zeros((self.num_params, num_data, num_data))
+        if self.ard:
+            grad[0 : self.num_params - 1, :, :] = grad_width64(X, width, G)
+        else:
+            pairwise_dists = spatial.distance.pdist(X / width, "euclidean")
+            grad[0, :, :] = G * spatial.distance.squareform(pairwise_dists**2)
+
+        grad[-1, :, :] = 2 * G
+        return grad
+
+    def get_cov(self, X, Z=None, params=None, diag=False):
+        """
+        compute the covariant matrix
+        Parameters
+        ----------
+        X: numpy.ndarray
+            N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+
+        Z: numpy.ndarray
+            N x d dimensional matrix. Each row of Z denotes the d-dimensional feature vector of search candidate.
+
+        params: numpy.ndarray
+            Parameters
+
+        diag: bool
+            If X is the diagonalization matrix, true.
+
+        Returns
+        -------
+        G: numpy.ndarray
+            covariant matrix
+        """
+        params, width, scale = self.prepare(params)
+        scale2 = scale**2
+
+        if Z is None:
+            if diag:
+                G = scale2 * np.ones(X.shape[0])
+            else:
+                pairwise_dists = spatial.distance.squareform(
+                    spatial.distance.pdist(X / width, "euclidean") ** 2
+                )
+                G = np.exp(-0.5 * pairwise_dists) * scale2
+        else:
+            pairwise_dists = (
+                spatial.distance.cdist(X / width, Z / width, "euclidean") ** 2
+            )
+            G = np.exp(-0.5 * pairwise_dists) * scale2
+
+        return G
+
+    def set_params(self, params):
+        """
+        set kernel parameters
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            Parameters for optimization.
+
+        """
+        params = self.supp_params(params)
+        self.params = params
+        self.width, self.scale = self.decomp_params(params)
+
+    def supp_params(self, params):
+        """
+        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
+        -------
+        params: numpy.ndarray
+
+        """
+        index = np.where(params[0:-1] > self.max_ln_width)
+        params[index[0]] = self.max_ln_width
+
+        index = np.where(params[0:-1] < self.min_ln_width)
+        params[index[0]] = self.min_ln_width
+
+        if params[-1] > self.max_ln_scale:
+            params[-1] = self.max_ln_scale
+
+        if params[-1] < self.min_ln_scale:
+            params[-1] = self.min_ln_scale
+
+        return params
+
+    def decomp_params(self, params):
+        """
+        decompose the parameters defined on the log region
+        into width and scale parameters
+
+        Parameters
+        ----------
+        params: numpy.ndarray
+            parameters
+
+        Returns
+        -------
+        width: float
+        scale: float
+        """
+
+        width = np.exp(params[0:-1])
+        scale = np.exp(params[-1])
+        return width, scale
+
+    def save(self, file_name):
+        """
+        save the gaussian kernel
+
+        Parameters
+        ----------
+        file_name: str
+            file name to save the information of the kernel
+
+        """
+        kwarg = {
+            "name": "gauss",
+            "params": self.params,
+            "ard": self.ard,
+            "num_dim": self.num_dim,
+            "max_ln_scale": self.max_ln_scale,
+            "min_ln_scale": self.min_ln_scale,
+            "max_ln_width": self.max_ln_width,
+            "min_ln_width": self.min_ln_width,
+            "num_params": self.num_params,
+        }
+        with open(file_name, "wb") as f:
+            np.savez(f, **kwarg)
+
+    def load(self, file_name):
+        """
+        Recovering the Gaussian kernel from file
+        Parameters
+        ----------
+         file_name: str
+            file name to load the information of the kernel
+
+        """
+        temp = np.load(file_name)
+
+        self.num_dim = temp["num_dim"]
+        self.ard = temp["ard"]
+        self.max_ln_scale = temp["max_ln_scale"]
+        self.min_ln_scale = temp["min_ln_scale"]
+        self.max_ln_width = temp["max_ln_width"]
+        self.min_ln_width = temp["min_ln_width"]
+        params = temp["params"]
+        self.set_params(params)
+
+    def get_params_bound(self):
+        """
+        Getting boundary array.
+
+        Returns
+        -------
+        bound: list
+            A num_params-dimensional array with the tuple (min_params, max_params).
+
+        """
+
+        if self.ard:
+            bound = [
+                (self.min_ln_width, self.max_ln_width) for i in range(0, self.num_dim)
+            ]
+        else:
+            bound = [(self.min_ln_width, self.max_ln_width)]
+
+        bound.append((self.min_ln_scale, self.max_ln_scale))
+        return bound
+
+    def cat_params(self, width, scale):
+        """
+        Taking the logarithm of width and scale parameters
+        and concatinate them into one ndarray
+
+        Parameters
+        ----------
+        width: int
+        scale: int
+
+        Returns
+        -------
+        params: numpy.ndarray
+            Parameters
+        """
+        params = np.zeros(self.num_params)
+        params[0:-1] = np.log(width)
+        params[-1] = np.log(scale)
+        return params
+
+    def rand_expans(self, num_basis, params=None):
+        """
+        Kernel Expansion
+
+        Parameters
+        ----------
+        num_basis: int
+            total number of basis
+        params: numpy.ndarray
+            Parameters
+
+        Returns
+        -------
+        tupple (W, b, amp)
+        """
+        params, width, scale = self.prepare(params)
+        scale2 = scale**2
+        amp = np.sqrt((2 * scale2) / num_basis)
+        W = np.random.randn(num_basis, self.num_dim) / width
+        b = np.random.rand(num_basis) * 2 * np.pi
+        return (W, b, amp)
+
+    def get_cand_params(self, X, t):
+        """
+        Getting candidate 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).
+
+        Returns
+        -------
+        params: numpy.ndarray
+
+        """
+        if self.ard:
+            # with ARD
+            width = np.zeros(self.num_dim)
+            scale = np.std(t)
+            u = np.random.uniform(0.4, 0.8)
+            width = u * (np.max(X, 0) - np.min(X, 0)) * np.sqrt(self.num_dim)
+
+            index = np.where(np.abs(width) < 1e-6)
+            width[index[0]] = 1e-6
+            params = np.append(np.log(width), np.log(scale))
+        else:
+            # without ARD
+            num_data = X.shape[0]
+            M = max(2000, int(np.floor(num_data / 5)))
+
+            dist = np.zeros(M)
+
+            for m in range(M):
+                a = np.random.randint(0, X.shape[0], 2)
+                dist[m] = np.linalg.norm(X[a[0], :] - X[a[1], :])
+
+            dist = np.sort(dist)
+            tmp = int(np.floor(M / 10))
+            n = np.random.randint(0, 5)
+            width = dist[(2 * n + 1) * tmp]
+            scale = np.std(t)
+            params = np.append(np.log(width + 1e-8), np.log(scale))
+        return params

physbo/gp/inf/__init__.py

@@ -0,0 +1,8 @@
+# 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 . import exact

physbo/gp/inf/exact.py

@@ -0,0 +1,231 @@
+# 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
+from ... import misc
+from copy import deepcopy
+
+
+def eval_marlik(gp, X, t, params=None):
+    """
+    Evaluating marginal likelihood.
+
+    Parameters
+    ----------
+    gp: physbo.gp.core.model
+    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).
+    params: numpy.ndarray
+        Parameters.
+
+    Returns
+    -------
+    marlik: float
+        Marginal likelihood.
+    """
+    ndata, ndims = X.shape
+    lik_params, prior_params = gp.decomp_params(params)
+
+    fmu = gp.prior.get_mean(ndata, params=prior_params)
+    G = gp.prior.get_cov(X, params=prior_params)
+    B = gp.lik.get_cov(ndata, params=lik_params)
+
+    A = G + B + 1e-8 * np.identity(ndata)
+    res = t - fmu
+    U = scipy.linalg.cholesky(A, check_finite=False)
+    alpha = scipy.linalg.solve_triangular(
+        U.transpose(), res, lower=True, overwrite_b=False, check_finite=False
+    )
+    marlik = (
+        0.5 * ndata * np.log(2 * np.pi)
+        + np.sum(np.log(np.diag(U)))
+        + 0.5 * np.inner(alpha, alpha)
+    )
+    return marlik
+
+
+def get_grad_marlik(gp, X, t, params=None):
+    """
+    Evaluating gradiant of marginal likelihood.
+
+    Parameters
+    ----------
+    gp: physbo.gp.core.model
+    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).
+    params: numpy.ndarray
+        Parameters.
+
+    Returns
+    -------
+    grad_marlik: numpy.ndarray
+        Gradiant of marginal likelihood.
+    """
+    ndata, ndims = X.shape
+    lik_params, prior_params = gp.decomp_params(params)
+
+    fmu = gp.prior.get_mean(ndata, prior_params)
+    G = gp.prior.get_cov(X, params=prior_params)
+    B = gp.lik.get_cov(ndata, lik_params)
+
+    A = G + B + 1e-8 * np.identity(ndata)
+    U = scipy.linalg.cholesky(A, check_finite=False)
+    res = t - fmu
+    alpha = misc.gauss_elim(U, res)
+    invA = scipy.linalg.inv(A, check_finite=False)
+
+    grad_marlik = np.zeros(gp.num_params)
+
+    """ lik """
+    if gp.lik.num_params != 0:
+        lik_grad = gp.lik.get_grad(ndata, lik_params)
+        temp = lik_grad.dot(alpha)
+        grad_marlik[0 : gp.lik.num_params] = -0.5 * temp.dot(
+            alpha
+        ) + 0.5 * misc.traceAB2(invA, lik_grad)
+
+    ntemp = gp.lik.num_params
+    """ prior """
+    if gp.prior.mean.num_params != 0:
+        mean_grad = gp.prior.get_grad_mean(ndata, prior_params)
+        grad_marlik[ntemp : ntemp + gp.prior.mean.num_params] = -np.inner(
+            alpha, mean_grad
+        )
+
+    ntemp += gp.prior.mean.num_params
+
+    if gp.prior.cov.num_params != 0:
+        cov_grad = gp.prior.get_grad_cov(X, prior_params)
+        temp = cov_grad.dot(alpha)
+        grad_marlik[ntemp:] = -0.5 * temp.dot(alpha) + 0.5 * misc.traceAB3(
+            invA, cov_grad
+        )
+
+    return grad_marlik
+
+
+def prepare(gp, X, t, params=None):
+    """
+
+    Parameters
+    ----------
+    gp: physbo.gp.core.model
+    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).
+    params: numpy.ndarray
+        Parameters.
+
+    Returns
+    -------
+    stats: tupple
+    """
+    ndata = X.shape[0]
+    ndims = X.shape[1]
+
+    if params is None:
+        params = np.copy(gp.params)
+
+    lik_params, prior_params = gp.decomp_params(params)
+
+    G = gp.prior.get_cov(X, params=prior_params)
+    fmu = gp.prior.get_mean(ndata, params=prior_params)
+    B = gp.lik.get_cov(ndata, params=lik_params)
+    A = G + B + 1e-8 * np.identity(ndata)
+    U = scipy.linalg.cholesky(A, check_finite=False)
+    residual = t - fmu
+    alpha = misc.gauss_elim(U, residual)
+    stats = (U, alpha)
+
+    return stats
+
+
+def get_post_fmean(gp, X, Z, params=None):
+    """
+    Calculating the mean of posterior
+
+    Parameters
+    ----------
+    gp: physbo.gp.core.model
+    X: numpy.ndarray
+        N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+    Z: numpy.ndarray
+        N x d dimensional matrix. Each row of Z denotes the d-dimensional feature vector of tests.
+    params: numpy.ndarray
+        Parameters.
+
+    Returns
+    -------
+    numpy.ndarray
+    """
+
+    ndata = X.shape[0]
+    ndims = X.shape[1]
+    ntest = Z.shape[0]
+
+    lik_params, prior_params = gp.decomp_params(params)
+
+    alpha = gp.stats[1]
+
+    fmu = gp.prior.get_mean(ntest)
+    G = gp.prior.get_cov(X=Z, Z=X, params=prior_params)
+
+    return G.dot(alpha) + fmu
+
+
+def get_post_fcov(gp, X, Z, params=None, diag=True):
+    """
+    Calculating the covariance of posterior
+
+    Parameters
+    ----------
+    gp: physbo.gp.core.model
+    X: numpy.ndarray
+        N x d dimensional matrix. Each row of X denotes the d-dimensional feature vector of search candidate.
+    Z: numpy.ndarray
+        N x d dimensional matrix. Each row of Z denotes the d-dimensional feature vector of tests.
+    params: numpy.ndarray
+        Parameters.
+    diag: bool
+        If X is the diagonalization matrix, true.
+    Returns
+    -------
+        numpy.ndarray
+    """
+
+    lik_params, prior_params = gp.decomp_params(params)
+
+    U = gp.stats[0]
+    alpha = gp.stats[1]
+
+    G = gp.prior.get_cov(X=X, Z=Z, params=prior_params)
+
+    invUG = scipy.linalg.solve_triangular(
+        U.transpose(), G, lower=True, overwrite_b=False, check_finite=False
+    )
+
+    if diag:
+        diagK = gp.prior.get_cov(X=Z, params=prior_params, diag=True)
+        diag_invUG2 = misc.diagAB(invUG.transpose(), invUG)
+        post_cov = diagK - diag_invUG2
+    else:
+        K = gp.prior.get_cov(X=Z, params=prior_params)
+        post_cov = K - np.dot(invUG.transpose(), invUG)
+
+    return post_cov

physbo/gp/lik/__init__.py

@@ -0,0 +1,8 @@
+# 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 .gauss import gauss