physbo 2.0.0__cp310-cp310-macosx_12_0_arm64.whl

physbo/blm/lik/_src/cov.py

@@ -0,0 +1,113 @@
+# 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 cov:
+    """
+    Covariance
+
+    Attributes
+    ==========
+    params: float
+        half of log of variance
+    nparams: int
+        number of parameters
+    sigma2: float
+        variance
+    prec: float
+        inv. of variance
+    """
+
+    def __init__(self, params=None):
+        self.params = params
+        if self.params is None:
+            self.params = np.log(1)
+        self.nparams = 1
+        self.sigma2, self.prec = self._trans_params(params)
+
+    def get_cov(self, N, params=None):
+        """
+        compute the covariance of prior
+
+        Parameters
+        ==========
+        N: int
+            dimension
+        params:
+            half of log of variance
+            (default: self.params)
+
+        Returns
+        =======
+        numpy.ndarray
+            NxN covariance matrix
+        """
+        if params is None:
+            params = self.params
+
+        sigma2, prec = self._trans_params(params)
+        return np.identity(N) * sigma2
+
+    def get_prec(self, N, params=None):
+        """
+        compute the precision of prior
+
+        Parameters
+        ==========
+        N: int
+            dimension
+        params:
+            half of log of variance
+            (default: self.params)
+
+        Returns
+        =======
+        numpy.ndarray
+            inverse of covariance matrix
+        """
+        if params is None:
+            params = self.params
+        sigma2, prec = self._trans_params(params)
+        return np.identity(N) * prec
+
+    def set_params(self, params):
+        """
+        set the parameter
+
+        Parameters
+        ==========
+        params: float
+            half of log of variance
+        """
+        self.params = params
+        self.sigma2, self.prec = self._trans_params(params)
+
+    def _trans_params(self, params=None):
+        """
+        transform the parameter into variance and precision
+
+        Parameters
+        ==========
+        params: float
+            half of log of variance
+            (default: self.params)
+
+        Returns
+        =======
+        sigma2: float
+            variance
+        prec: float
+            precision (inv. of variance)
+        """
+        if params is None:
+            params = np.copy(self.params)
+
+        sigma2 = np.exp(2 * params)
+        prec = 1 / sigma2
+        return sigma2, prec

physbo/blm/lik/gauss.py

@@ -0,0 +1,136 @@
+# 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
+
+    Attributes
+    ==========
+    linear
+    cov: blm.lik.cov
+        covariance
+    stats
+    """
+
+    def __init__(self, linear, cov):
+        self.linear = linear
+        self.cov = cov
+        self.stats = ()
+
+    def get_cov(self, N, params=None):
+        """
+        Returns covariance matrix
+
+        Parameters
+        ==========
+        N: int
+            dimension
+        params: float
+            half of log of variance
+            (default: self.cov.params)
+
+        Returns
+        =======
+        numpy.ndarray
+            NxN covariance matrix
+        """
+        if params is None:
+            params = np.copy(self.cov.params)
+
+        return self.cov.get_cov(N, params)
+
+    def get_prec(self, N, params=None):
+        """
+        Returns precision matrix
+
+        Parameters
+        ==========
+        N: int
+            dimension
+        params: float
+            half of log of variance
+            (default: self.cov.params)
+
+        Returns
+        =======
+        numpy.ndarray
+            NxN precision matrix
+        """
+
+        if params is None:
+            params = np.copy(self.cov.params)
+
+        return self.cov.get_cov(N, params)
+
+    def get_basis(self, X):
+        """
+        calculates value of basis function at input
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            input
+
+        See also
+        ========
+        blm.basis.fourier.get_basis
+        """
+        return self.linear.basis.get_basis(X)
+
+    def get_mean(self, X, Psi=None, params=None, bias=None):
+        """
+        calculates mean value
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            raw input
+        Psi: numpy.ndarray
+            value of feature maps
+        params: numpy.ndarray
+            weight
+        bias: float
+            bias
+
+        See also
+        ========
+        blm.basis.fourier.get_mean
+        """
+        return self.linear.get_mean(X, Psi, params, bias)
+
+    def set_params(self, params):
+        """
+        sets parameters
+        """
+        self.linear.set_params(params)
+
+    def set_bias(self, bias):
+        """
+        sets bias
+        """
+        self.linear.set_bias(bias)
+
+    def sampling(self, fmean):
+        """
+        draws samples
+
+        Parameters
+        ==========
+        fmean: numpy.ndarray
+            means of samples
+
+        Returns
+        =======
+        samples: numpy.ndarray
+        """
+        num_data = fmean.shape[0]
+        eps = np.sqrt(self.cov.sigma2) * np.random.randn(num_data)
+        return fmean + eps

physbo/blm/lik/linear.py

@@ -0,0 +1,117 @@
+# 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 linear:
+    """
+
+    Attributes
+    ==========
+    basis:
+        basis for random feature map
+    nbasis: int
+        number of basis
+    bias:
+    params:
+    _init_params:
+        initial value of the parameter
+    """
+
+    def __init__(self, basis, params=None, bias=None):
+        self.basis = basis
+        self.nbasis = basis.nbasis
+        self._init_params = params
+        self.bias = bias
+        self.params = params
+
+        if params is None:
+            self.params = np.zeros(self.nbasis)
+        self.nparams = self.nbasis
+
+    def get_mean(self, X, Psi=None, params=None, bias=None):
+        """
+        calculate mean values
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            input as an N-by-d matrix
+        Psi: numpy.ndarray
+            feature maps ``Psi(X)`` as an N-by-l matrix
+            (default: self.get_basis(X))
+        params: numpy.ndarray
+            weight as a vector with size l
+            (default: self.params)
+        bias: float
+            (default: self.bias)
+
+        Returns
+        =======
+        numpy.ndarray
+            Psi * params + bias
+
+        """
+        if params is None:
+            params = np.copy(self.params)
+
+        if bias is None:
+            bias = np.copy(self.bias)
+
+        if Psi is None:
+            Psi = self.get_basis(X)
+
+        return Psi.dot(params) + bias
+
+    def set_params(self, params):
+        """
+        set parameters
+
+        Parameters
+        ==========
+        params: np.ndarray
+        """
+        self.params = params
+
+    def set_bias(self, bias):
+        """
+        set bias
+
+        Parameters
+        ==========
+        bias: float
+        """
+        self.bias = bias
+
+    def _init_params(self, params):
+        """
+        initialize parameters
+
+        Parameters
+        ==========
+        params: np.ndarray
+            (default: numpy.zeros(self.nbasis))
+        """
+        if params is None:
+            self.params = np.zeros(self.nbasis)
+
+        self.params = params
+
+    def _init_bias(self, bias):
+        """
+        initialize bias
+
+        Parameters
+        ==========
+        bias: float
+            (default: 0)
+        """
+        if bias is None:
+            self.bias = 0
+
+        self.bias = bias

physbo/blm/predictor.py

@@ -0,0 +1,238 @@
+# 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 using Baysean linear model
+
+    Attributes
+    ==========
+    blm: physbo.blm.core.model
+    config: physbo.misc.set_config
+        configuration
+    """
+
+    def __init__(self, config, model=None):
+        """
+
+        Parameters
+        ==========
+        config: physbo.misc.set_config
+            configuration
+        model: physbo.gp.core.model
+
+        See also
+        ========
+        physbo.base_predictor
+        """
+        super(predictor, self).__init__(config, model)
+        self.blm = None
+
+    def fit(self, training, num_basis=None):
+        """
+        fit 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 num_basis is None:
+            num_basis = 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.blm = self.model.export_blm(num_basis)
+        self.delete_stats()
+
+    def prepare(self, training):
+        """
+        initializes model by using training data set
+
+        Parameters
+        ==========
+        training: physbo.variable
+            dataset for training
+        """
+        self.blm.prepare(training.X, training.t, training.Z)
+
+    def delete_stats(self):
+        """
+        resets model
+        """
+        self.blm.stats = None
+
+    def get_basis(self, X):
+        """
+        calculates feature maps Psi(X)
+
+        Parameters
+        ==========
+        X: numpy.ndarray
+            inputs
+
+        Returns
+        =======
+        Psi: numpy.ndarray
+            feature maps
+        """
+        return self.blm.lik.get_basis(X)
+
+    def get_post_fmean(self, training, test):
+        """
+        calculates 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.blm.stats is None:
+            self.prepare(training)
+        return self.blm.get_post_fmean(test.X, test.Z)
+
+    def get_post_fcov(self, training, test):
+        """
+        calculates 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
+
+        Returns
+        =======
+        numpy.ndarray
+        """
+        if self.blm.stats is None:
+            self.prepare(training)
+        return self.blm.get_post_fcov(test.X, test.Z)
+
+    def get_post_params(self, training, test):
+        """
+        calculates posterior weights
+
+        Parameters
+        ==========
+        training: physbo.variable
+            training dataset. If already trained, the model does not use this.
+        test: physbo.variable
+            inputs (not used)
+
+        Returns
+        =======
+        numpy.ndarray
+        """
+        if self.blm.stats is None:
+            self.prepare(training)
+        return self.blm.get_post_params_mean()
+
+    def get_post_samples(self, training, test, N=1, alpha=1.0):
+        """
+        draws 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
+        N: int
+            number of samples
+            (default: 1)
+        alpha: float
+            noise for sampling source
+            (default: 1.0)
+
+        Returns
+        =======
+        numpy.ndarray
+        """
+        if self.blm.stats is None:
+            self.prepare(training)
+        return self.blm.post_sampling(test.X, Psi=test.Z, N=N, alpha=alpha)
+
+    def get_predict_samples(self, training, test, N=1):
+        """
+        draws 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)
+        alpha: float
+            noise for sampling source
+            (default: 1.0)
+
+        Returns
+        =======
+        numpy.ndarray (N x len(test))
+        """
+        if self.blm.stats is None:
+            self.prepare(training)
+        return self.blm.predict_sampling(test.X, Psi=test.Z, N=N).transpose()
+
+    def update(self, training, test):
+        """
+        updates the model.
+
+        If not yet initialized (prepared), the model will be prepared by ``training``.
+        Otherwise, the model will be updated by ``test``.
+
+        Parameters
+        ==========
+        training: physbo.variable
+            training dataset for initialization (preparation).
+            If already prepared, the model ignore this.
+        test: physbo.variable
+            training data for update.
+            If not prepared, the model ignore this.
+        """
+        if self.model.stats is None:
+            self.prepare(training)
+            return None
+
+        if hasattr(test.t, "__len__"):
+            N = len(test.t)
+        else:
+            N = 1
+
+        if N == 1:
+            if test.Z is None:
+                if test.X.ndim == 1:
+                    self.blm.update_stats(test.X, test.t)
+                else:
+                    self.blm.update_stats(test.X[0, :], test.t)
+            else:
+                if test.Z.ndim == 1:
+                    self.blm.update_stats(test.X, test.t, psi=test.Z)
+                else:
+                    self.blm.update_stats(test.X[0, :], test.t, psi=test.Z[0, :])
+        else:
+            for n in range(N):
+                if test.Z is None:
+                    self.blm.update_stats(test.X[n, :], test.t[n])
+                else:
+                    self.blm.update_stats(test.X[n, :], test.t[n], psi=test.Z[n, :])

physbo/blm/prior/__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