mvBayes 1.0.3__tar.gz

mvbayes-1.0.3/LICENSE

@@ -0,0 +1,2 @@
+YEAR: 2025
+COPYRIGHT HOLDER: 2025 National Technology & Engineering Solutions of Sandia, LLC (NTESS). Under the terms of Contract DE-NA0003525 with NTESS, the U.S. Government retains certain rights in this software.

mvbayes-1.0.3/PKG-INFO

@@ -0,0 +1,20 @@
+Metadata-Version: 2.4
+Name: mvBayes
+Version: 1.0.3
+Summary: Multivariate Bayesian Modeling
+Author-email: Gavin Collins <gqcolli@sandia.gov>, "J. Derek Tucker" <jdtuck@sandia.gov>
+License: BSD-3
+Project-URL: Homepage, https://cee-gitlab.sandia.gov/gqcolli/mvBayes
+Requires-Python: >=3.9
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: scipy
+Requires-Dist: matplotlib
+Requires-Dist: scikit-learn
+Requires-Dist: patsy
+Provides-Extra: optional
+Requires-Dist: pathos; extra == "optional"
+Requires-Dist: fdasrsf; extra == "optional"
+Requires-Dist: pyBASS; extra == "optional"
+Requires-Dist: pyBayesPPR; extra == "optional"
+Dynamic: license-file

mvbayes-1.0.3/README.md

@@ -0,0 +1,29 @@
+[![Build](https://github.com/sandialabs/mvBayesPy/actions/workflows/python-package.yml/badge.svg)](https://github.com/sandialabs/mvBayesPy/actions/workflows/python-package.yml)
+# mvBayes
+
+A Python implementation of the multivariate Bayesian regression (mvBayes) framework. Decomposes a multivariate/functional response using a user-specified orthogonal basis decomposition, and then models each basis component independently using an arbitrary user-specified (univariate) Bayesian regression model. Includes prediction and plotting methods.
+
+## Installation
+------------------------------------------------------------------------------
+
+To install the most up to date version on github
+> `pip install -e .`
+
+please see [requirements](requirements.txt) for a list of packages `mvBayes`
+depends on
+
+------------------------------------------------------------------------------
+
+
+## Examples
+* [Friedman Example](examples/friedman_demo.py) - An extension of the "Friedman function" to functional response. The Bayesian regression model here is BASS (Bayesian Adaptive Smoothing Splines, see https://github.com/lanl/pyBASS)
+
+
+## References
+
+
+************
+
+Author: Gavin Q. Collins and J. Derek Tucker
+Sandia National Laboratories
+

mvbayes-1.0.3/mvBayes/__init__.py

@@ -0,0 +1,3 @@
+# __init__.py
+
+from .mvBayes import *

mvbayes-1.0.3/mvBayes/cov.py

@@ -0,0 +1,84 @@
+import numpy as np
+from scipy.optimize import minimize_scalar
+from scipy.linalg import toeplitz
+
+
+def covDiag(resid):
+    cov = np.diag(resid.var(axis=0))
+    
+    return cov
+
+
+def covMA1(resid, varEqual=True):
+    nMV = resid.shape[1]
+    
+    if nMV == 1:
+        return np.array([[1]])
+    
+    if varEqual is True:
+        std = np.std(resid, ddof=1).reshape((1,))
+    else:
+        std = np.std(resid, ddof=1, axis=0)
+    C = std[:, None] * std[None, :]
+    covFull = np.cov(resid.T)
+    
+    def getMA1(coef):
+        theta = np.hstack([1, coef, np.repeat(0, nMV-2)])
+        return toeplitz(theta)
+    
+    def minLik(coef):
+        covMA1 = C * getMA1(coef)
+        D, Q = np.linalg.eigh(covMA1)
+        logDetCov = np.sum(np.log(D))
+        CovInvMA1 = Q @ np.diag(1/D) @ Q.T
+        return logDetCov + np.sum(CovInvMA1 * covFull)
+        
+    coef = minimize_scalar(
+        minLik,
+        bounds = (-0.5, 0.5)
+    ).x
+    
+    return C * getMA1(coef), coef
+
+
+def covAR1(resid, varEqual=True):
+    nMV = resid.shape[1]
+    
+    if nMV == 1:
+        return np.array([[1]])
+    
+    if varEqual is True:
+        std = np.std(resid, ddof=1).reshape((1,))
+    else:
+        std = np.std(resid, ddof=1, axis=0)
+    C = std[:, None] * std[None, :]
+    covFull = np.cov(resid.T)
+    
+    def getAR1(coef):
+        theta = coef ** np.arange(nMV)
+        return toeplitz(theta)
+    
+    if nMV <= 3:
+        def minLik(coef):
+            covAR1 = C * getAR1(coef)
+            D, Q = np.linalg.eigh(covAR1)
+            logDetCov = np.sum(np.log(D))
+            CovInvAR1 = Q @ np.diag(1/D) @ Q.T
+            return logDetCov + np.sum(CovInvAR1 * covFull)
+    else: # compute closed form solution for AR(1)
+        def minLik(coef):
+            logDetCov = (nMV - 1) * np.log(1 - coef**2)
+            theta = np.hstack([1, -coef, np.repeat(0, nMV-2)]) / (1 - coef**2)
+            CorInvAR1 = toeplitz(theta)
+            for i in range(1, nMV-1):
+                CorInvAR1[i, i] += coef**2 / (1 - coef**2)
+            CovInvAR1 = CorInvAR1 / C
+            return logDetCov + np.sum(CovInvAR1 * covFull)
+        
+    coef = minimize_scalar(
+        minLik,
+        bounds = (-1+1e-5, 1-1e-5)
+    ).x
+    
+    return C * getAR1(coef), coef
+

mvbayes-1.0.3/mvBayes/cv.py

@@ -0,0 +1,149 @@
+import numpy as np
+import time
+import mvBayes as mb
+from scipy.stats import multivariate_normal
+
+def mvCV(bayesModel, X, Y, nTrain=None, nTest=None, nRep=1, seed=None, coverageTarget=0.95, idxSamples="default", uqTruncMethod="gaussian", **kwargs):
+    """
+    Cross-Validation (CV) of a Multivariate Bayesian Regression Model
+    
+    Parameters:
+        bayesModel: A Bayesian regression model-fitting function, with first argument taking an nxp input matrix and second argument taking an n-vector of numeric responses.
+        X: A matrix of predictors of dimension nxp, where n is the total number of examples (including training and test sets) and p is the number of inputs (features).
+        Y: A response matrix of dimension nxq, where q is the number of multivariate/functional responses.
+        nTrain: Number of examples to use in the training set. If None, nTrain = n - nTest; unless nTest is also None, in which case nTrain = ceil(n/2).
+        nTest: Number of examples to use in the test set. If None, nTest = n - nTrain.
+        nRep: Number of repetitions of CV process.
+        seed: Randomization seed, for replication of the train/test split. If None, no seed is set.
+        coverageTarget: Level of coverage desired (default: 0.95).
+        idxSamples: Which samples to use in CV (default: "all").
+        uqTruncMethod: Method to use for UQ truncation ("gaussian" or "empirical").
+        **kwargs: Additional arguments to mvBayes, including arguments to bayesModel.
+    
+    Returns:
+        A dictionary containing the out-of-sample RMSE for each replication, fitting and prediction times, and other metrics.
+    """
+    # Setup
+    n, p = X.shape
+    alpha = 1 - coverageTarget
+
+    if nTest is None:
+        if nTrain is None:
+            nTest = n // 2  # half in test set
+            nTrain = n - nTest
+        elif nTrain >= n:
+            raise ValueError("Must have nTrain < nrow(X)")
+        else:
+            nTest = n - nTrain
+    else:
+        if nTest >= n:
+            raise ValueError("Must have nTest < nrow(X)")
+        elif nTrain is None:
+            nTrain = n - nTest
+        elif nTrain + nTest > n:
+            raise ValueError("Must have nTrain + nTest <= n")
+
+    # Get fold indices
+    np.random.seed(seed)
+    idxTest = [np.random.choice(n, size=nTest, replace=False) for _ in range(nRep)]
+    idxTrain = [np.random.choice(np.setdiff1d(np.arange(n), idx), size=nTrain, replace=False) for idx in idxTest]
+    np.random.seed(None)  # Reset seed
+
+    # Run CV
+    rmse = np.zeros(nRep)
+    rSquared = np.zeros(nRep)
+    coverage = np.zeros(nRep)
+    intervalWidth = np.zeros(nRep)
+    intervalScore = np.zeros(nRep)
+    fitTime = np.zeros(nRep)
+    predictTime = np.zeros(nRep)
+
+    for r in range(nRep):
+        # Set up train/test split
+        Xtrain, Ytrain = X[idxTrain[r], :], Y[idxTrain[r], :]
+        Xtest, Ytest = X[idxTest[r], :], Y[idxTest[r], :]
+
+        # Fit models
+        startFit = time.time()
+        fit = mb.mvBayes(bayesModel, Xtrain, Ytrain, **kwargs)
+        fitTime[r] = time.time() - startFit
+
+        # Predict
+        startPred = time.time()
+        preds = fit.predict(Xtest, idxSamples=idxSamples)
+        predictTime[r] = time.time() - startPred
+
+        Yhat = np.median(preds, axis=0)
+
+        # Calculate RMSE and R-squared
+        rmse[r] = np.sqrt(np.mean((Ytest - Yhat) ** 2))
+        rSquared[r] = 1 - np.mean((Ytest - Yhat) ** 2) / np.mean((Ytest - np.mean(Ytrain, axis=0)) ** 2)
+
+        # Get truncation error for UQ
+        if uqTruncMethod == "gaussian":
+            truncErrorVar = np.cov(fit.basisInfo.truncError, rowvar=False)
+            truncError = multivariate_normal.rvs(
+                mean=np.zeros(truncErrorVar.shape[0]),
+                cov=truncErrorVar,
+                size=np.prod(preds.shape[:2])
+            ).reshape(preds.shape)
+        elif uqTruncMethod == "empirical":
+            idxResample = np.random.choice(nTrain, size=np.prod(preds.shape[:2]), replace=True)
+            truncError = fit.basisInfo.truncError[idxResample, :].reshape(preds.shape)
+        preds += truncError
+        del truncError
+
+        # Get regression error for UQ
+        coefsResidError = np.zeros(preds.shape[:2] + (fit.basisInfo.nBasis, ))
+        for k in range(fit.basisInfo.nBasis):
+            residSD = np.repeat(
+                fit.bmList[k].samples.residSD,
+                preds.shape[1]
+            ).reshape(preds.shape[:2])
+            coefsResidError[:, :, k] = np.random.normal(
+                0.0,
+                residSD,
+                preds.shape[:2]
+            )
+        residError = coefsResidError @ fit.basisInfo.basis
+        del coefsResidError
+        preds += residError
+        del residError
+
+        # Calculate distance from posterior mean
+        distBound = np.zeros(nTest)
+        for idx in range(nTest):
+            distSamples = np.sqrt(np.mean((preds[:, idx, :] - Yhat[idx, :]) ** 2, axis=1))
+            distBound[idx] = np.quantile(distSamples, coverageTarget)
+        distTest = np.sqrt(np.mean((Ytest - Yhat) ** 2, axis=1))
+
+        # Calculate UQ metrics
+        distRatio = distTest / distBound
+        coverage[r] = np.mean(distRatio <= 1)
+        intervalWidth[r] = np.exp(np.mean(np.log(distBound)))
+        intervalScore[r] = intervalWidth[r] * np.exp(np.mean(np.log(distRatio) * (distRatio > 1)) / alpha)
+
+    # Output results
+    out = {
+        "rmse": rmse,
+        "rSquared": rSquared,
+        "coverageTarget": coverageTarget,
+        "coverage": coverage,
+        "intervalWidth": intervalWidth,
+        "intervalScore": intervalScore,
+        "fitTime": fitTime,
+        "predictTime": predictTime,
+        "effectiveArgs": {
+            "nTrain": nTrain,
+            "nTest": nTest,
+            "nRep": nRep,
+            "seed": seed,
+            "coverageTarget": coverageTarget,
+            "idxSamples": idxSamples,
+            "uqTruncMethod": uqTruncMethod
+        }
+    }
+
+    return out
+
+