physbo 2.0.0__cp310-cp310-macosx_12_0_arm64.whl

physbo/__init__.py

@@ -0,0 +1,17 @@
+# 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 gp
+from . import opt
+from . import blm
+from . import misc
+from . import search
+from . import predictor
+from .predictor import base_predictor
+from .variable import variable
+
+__version__ = "2.0.0"

physbo/blm/__init__.py

@@ -0,0 +1,17 @@
+# 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/.
+
+""" Bayesian Linear Model
+"""
+
+from . import basis
+from . import prior
+from . import lik
+from . import inf
+
+from .core import model
+from .predictor import predictor

physbo/blm/basis/__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 .fourier import fourier

physbo/blm/basis/fourier.py

@@ -0,0 +1,148 @@
+# 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
+
+
+class fourier:
+    """
+    random feature maps
+    ``Psi(X; W,b) = cos[X * Wt + b] * alpha``
+    where
+
+        - X: input, N-by-d matrix
+        - W: weight, l-by-d matrix
+        - Wt: transpose of W
+        - b: bias, 1-by-l matrix
+        - alpha: coefficient
+
+    and
+
+        - N: number of data
+        - d: dimension of input
+        - l: number of basis
+
+    Attributes
+    ==========
+    params: Tuple
+        W, b, alpha
+    nbasis: int
+        number of basis
+
+    References
+    ==========
+    A. Rahimi and B. Recht, "Random features for large-scale kernel machines,"
+    in "Advances in neural information processing systems," 2007, pp. 1177-1184.
+    """
+
+    def __init__(self, params):
+        """
+        Parameters
+        ----------
+        params: Tuple
+            W, b, alpha
+        """
+        self._check_params(params)
+        self._check_len_params(params)
+        self.params = params
+        self.nbasis = self.params[1].shape[0]
+
+    def get_basis(self, X, params=None):
+        """
+        compute the value of basis
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            input
+        params: Tuple
+            W, b, alpha
+            (default: self.params)
+
+        Returns
+        =======
+        Psi(X; W,b): numpy.ndarray
+            N-by-l matrix
+
+            ``cos[X * Wt + b] * alpha``
+
+            where ``Wt`` is the transpose of ``W``.
+        """
+        if params is None:
+            params = self.params
+
+        self._check_params(params)
+        self._check_len_params(params)
+
+        return np.cos(np.dot(X, params[0].transpose()) + params[1]) * params[2]
+
+    def set_params(self, params):
+        """
+        update basis parameters
+
+        Parameters
+        ==========
+        params: tuple
+            W, b, alpha
+
+        """
+        self._check_params(params)
+        self._check_len_params(params)
+        self.params = params
+
+    def show(self):
+        """
+        print parameters
+        """
+        print("W = ", self.params[0])
+        print("b = ", self.params[1])
+        print("alpha = ", self.params[2])
+
+    def _check_params(self, params):
+        """
+        Parameters
+        ==========
+        params: tuple
+            W, b, alpha
+
+        Raises
+        ======
+        ValueError
+            if ``params`` is not a 3-dimensional tuple
+        """
+        if not isinstance(params, tuple):
+            raise ValueError("The variable < params > must be a tuple.")
+
+        if len(params) != 3:
+            raise ValueError("The variable < params > must be 3-dimensional tuple.")
+
+    def _check_len_params(self, params):
+        """
+        Parameters
+        ==========
+        params: tuple
+            W, b, alpha
+
+
+        Raises
+        ======
+        ValueError
+            when dim of W and b are mismatch
+            or alpha is not a scalar
+        """
+        if params[0].shape[0] != params[1].shape[0]:
+            raise ValueError(
+                "The length of 0-axis of W must be same as the length of b."
+            )
+
+        if hasattr(params[2], "__len__"):
+            if len(params[2]) != 1:
+                raise ValueError("The third entry of <params> must be a scalar.")
+            else:
+                if isinstance(params[2], str):
+                    raise ValueError("The third entry of <params> must be a scalar.")

physbo/blm/core/__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 .model import model

physbo/blm/core/model.py

@@ -0,0 +1,257 @@
+# 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
+from .. import inf
+
+
+class model:
+    """
+    Baysean Linear Model
+
+    Attributes
+    ==========
+    prior: physbo.blm.prior.gauss
+        prior distribution of weights
+    lik: physbo.blm.lik.gauss
+        kernel
+    nbasis: int
+        number of features in random feature map
+    stats: Tuple
+        auxially parameters for sampling
+    method: str
+        sampling method
+    """
+
+    def __init__(self, lik, prior, options={}):
+        self.prior = prior
+        self.lik = lik
+        self.nbasis = self.lik.linear.basis.nbasis
+        self._init_prior(prior)
+        self._set_options(options)
+        self.stats = ()
+
+    def prepare(self, X, t, Psi=None):
+        """
+        initializes model by using the first training dataset
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            inputs
+        t: numpy.ndarray
+            target (label)
+        Psi: numpy.ndarray
+            feature maps
+
+        See also
+        ========
+        physbo.blm.inf.exact.prepare
+        """
+        if self.method == "exact":
+            inf.exact.prepare(blm=self, X=X, t=t, Psi=Psi)
+        else:
+            pass
+
+    def update_stats(self, x, t, psi=None):
+        """
+        updates model by using another training data
+
+        Parameters
+        ==========
+        x: numpy.ndarray
+            input
+        t: float
+            target (label)
+        psi: numpy.ndarray
+            feature map
+
+        See also
+        ========
+        physbo.blm.inf.exact.update_stats
+        """
+        if self.method == "exact":
+            self.stats = inf.exact.update_stats(self, x, t, psi)
+        else:
+            pass
+
+    def get_post_params_mean(self):
+        """
+        calculates posterior mean of weights
+
+        Returns
+        =======
+        numpy.ndarray
+
+        See also
+        ========
+        physbo.blm.inf.exact.get_post_params_mean
+        """
+        if self.method == "exact":
+            self.lik.linear.params = inf.exact.get_post_params_mean(blm=self)
+
+    def get_post_fmean(self, X, Psi=None, w=None):
+        """
+        calculates posterior mean of model (function)
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            inputs
+        Psi: numpy.ndarray
+            feature maps
+        w: numpy.ndarray
+            weight
+
+        See also
+        ========
+        physbo.blm.inf.exact.get_post_fmean
+        """
+        if self.method == "exact":
+            fmu = inf.exact.get_post_fmean(self, X, Psi, w)
+        else:
+            pass
+        return fmu
+
+    def sampling(self, w_mu=None, N=1, alpha=1.0):
+        """
+        draws samples of weights
+
+        Parameters
+        ==========
+        blm: physbo.blm.core.model
+            model
+        w_mu: numpy.ndarray
+            mean of weight
+        N: int
+            the number of samples
+            (default: 1)
+        alpha: float
+            noise for sampling source
+            (default: 1.0)
+
+        Returns
+        =======
+        numpy.ndarray
+            samples of weights
+
+        See also
+        ========
+        physbo.blm.inf.exact.sampling
+        """
+        if self.method == "exact":
+            w_hat = inf.exact.sampling(self, w_mu, N, alpha=alpha)
+        else:
+            pass
+        return w_hat
+
+    def post_sampling(self, Xtest, Psi=None, N=1, alpha=1.0):
+        """
+        draws samples of mean value of model
+
+        Parameters
+        ==========
+        Xtest: numpy.ndarray
+            inputs
+        Psi: numpy.ndarray
+            feature maps
+            (default: ``blm.lik.get_basis(Xtest)``)
+        N: int
+            number of samples
+            (default: 1)
+        alpha: float
+            noise for sampling source
+
+        Returns
+        =======
+        numpy.ndarray
+        """
+        if Psi is None:
+            Psi = self.lik.get_basis(Xtest)
+        w_hat = self.sampling(N=N, alpha=alpha)
+        return Psi.dot(w_hat) + self.lik.linear.bias
+
+    def predict_sampling(self, Xtest, Psi=None, N=1):
+        """
+        draws samples from model
+
+        Parameters
+        ==========
+        Xtest: numpy.ndarray
+            inputs
+        Psi: numpy.ndarray
+            feature map
+            (default: ``blm.lik.get_basis(Xtest)``)
+        N: int
+            number of samples
+            (default: 1)
+
+        Returns
+        =======
+        numpy.ndarray
+        """
+        if Xtest.shape[0] == 0:
+            return np.zeros((0, N))
+        fmean = self.post_sampling(Xtest, Psi, N=N)
+        A = np.random.randn(Xtest.shape[0], N)
+        return fmean + np.sqrt(self.lik.cov.sigma2) * A
+
+    def get_post_fcov(self, X, Psi=None, diag=True):
+        """
+        calculates posterior covariance of model
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            inputs
+        Psi: numpy.ndarray
+            feature maps
+            (default: blm.lik.linear.basis.get_basis(X))
+        diag: bool
+            if True, returns only variances as a diagonal matrix
+            (default: True)
+
+        Returns
+        =======
+        numpy.ndarray
+
+        See also
+        ========
+        physbo.blm.inf.exact.get_post_fcov
+        """
+        if self.method == "exact":
+            fcov = inf.exact.get_post_fcov(self, X, Psi, diag=True)
+        else:
+            pass
+        return fcov
+
+    def _set_options(self, options):
+        """
+        read options
+
+        Parameters
+        ==========
+        options: dict
+
+            - 'method' : sampling method
+
+                - 'exact' (default)
+        """
+        self.method = options.get("method", "exact")
+
+    def _init_prior(self, prior):
+        """
+        sets the prior distribution
+
+        Parameters
+        ==========
+        prior: physbo.blm.prior.gauss
+            if None, prior.gauss(self.nbasis)
+        """
+        if prior is None:
+            prior = prior.gauss(self.nbasis)
+        self.prior = prior

physbo/blm/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/blm/inf/exact.py

@@ -0,0 +1,192 @@
+# 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
+
+import physbo.misc as misc
+
+
+def prepare(blm, X, t, Psi=None):
+    """
+    initializes auxiaialy parameters for quick sampling
+
+    ``blm.stats`` will be updated.
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+        model
+    X: numpy.ndarray
+        inputs
+    t: numpy.ndarray
+        target (label)
+    Psi:
+        feature maps (default: blm.lik.get_basis(X))
+    """
+    if Psi is None:
+        Psi = blm.lik.get_basis(X)
+    PsiT = Psi.transpose()
+    G = np.dot(PsiT, Psi) * blm.lik.cov.prec
+    A = G + blm.prior.get_prec()
+    U = scipy.linalg.cholesky(A, check_finite=False)
+    b = PsiT.dot(t - blm.lik.linear.bias)
+    alpha = misc.gauss_elim(U, b)
+    blm.stats = (U, b, alpha)
+
+
+def update_stats(blm, x, t, psi=None):
+    """
+    calculates new auxiaialy parameters for quick sampling by fast-update
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+        model
+    x: numpy.ndarray
+        input
+    t: numpy.ndarray
+        target (label)
+    psi:
+        feature map (default: blm.lik.get_basis(X))
+
+    Returns
+    =======
+    (U, b, alpha): Tuple
+        new auxially parameters
+
+    Notes
+    =====
+    ``blm.stats[0]`` (U) will be mutated while the others not.
+    """
+    if psi is None:
+        psi = blm.lik.get_basis(x)
+    U = blm.stats[0]
+    b = blm.stats[1] + (t - blm.lik.linear.bias) * psi
+    misc.cholupdate(U, psi * np.sqrt(blm.lik.cov.prec))
+    alpha = misc.gauss_elim(U, b)
+    return (U, b, alpha)
+
+
+def sampling(blm, w_mu=None, N=1, alpha=1.0):
+    """
+    draws samples of weights
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+        model
+    w_mu: numpy.ndarray
+        mean of weight
+    N: int
+        the number of samples
+        (default: 1)
+    alpha: float
+        noise for sampling source
+        (default: 1.0)
+
+    Returns
+    =======
+    numpy.ndarray
+        samples of weights
+    """
+    if w_mu is None:
+        w_mu = get_post_params_mean(blm)
+    if N == 1:
+        z = np.random.randn(blm.nbasis) * alpha
+    else:
+        z = np.random.randn(blm.nbasis, N) * alpha
+
+    U = blm.stats[0]
+    invUz = scipy.linalg.solve_triangular(
+        U, z, lower=False, overwrite_b=False, check_finite=False
+    )
+    return (invUz.transpose() + w_mu).transpose()
+
+
+def get_post_params_mean(blm):
+    """
+    calculates mean of weight
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+
+    Returns
+    =======
+    numpy.ndarray
+    """
+    return blm.stats[2] * blm.lik.cov.prec
+
+
+def get_post_fmean(blm, X, Psi=None, w=None):
+    """
+    calculates posterior mean of model
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+    X: numpy.ndarray
+        inputs
+    Psi: numpy.ndarray
+        feature maps
+        (default: blm.lik.linear.basis.get_basis(X))
+    w: numpy.ndarray
+        weights
+        (default: get_post_params_mean(blm))
+
+    Returns
+    =======
+    numpy.ndarray
+    """
+    if Psi is None:
+        Psi = blm.lik.linear.basis.get_basis(X)
+
+    if w is None:
+        w = get_post_params_mean(blm)
+    return Psi.dot(w) + blm.lik.linear.bias
+
+
+def get_post_fcov(blm, X, Psi=None, diag=True):
+    """
+    calculates posterior covariance of model
+
+    Parameters
+    ==========
+    blm: physbo.blm.core.model
+    X: numpy.ndarray
+        inputs
+    Psi: numpy.ndarray
+        feature maps
+        (default: blm.lik.linear.basis.get_basis(X))
+    diag: bool
+        if True, returns only variances as a diagonal matrix
+        (default: True)
+
+    Returns
+    =======
+    numpy.ndarray
+    """
+    if Psi is None:
+        Psi = blm.lik.linear.basis.get_basis(X)
+
+    U = blm.stats[0]
+    R = scipy.linalg.solve_triangular(
+        U.transpose(),
+        Psi.transpose(),
+        lower=True,
+        overwrite_b=False,
+        check_finite=False,
+    )
+    RT = R.transpose()
+
+    if diag is True:
+        fcov = misc.diagAB(RT, R)
+    else:
+        fcov = np.dot(RT, R)
+
+    return fcov

physbo/blm/lik/__init__.py

@@ -0,0 +1,10 @@
+# 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 ._src import cov
+from .linear import linear
+from .gauss import gauss

physbo/blm/lik/_src/__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 .cov import cov