prisma-oed 0.0.1__tar.gz

prisma_oed-0.0.1/LICENSE.txt

@@ -0,0 +1,30 @@
+BSD 3-Clause License
+
+Copyright 2026 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.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

prisma_oed-0.0.1/LICENSES_bundled.txt

@@ -0,0 +1,8 @@
+This software uses methods derived from the SciPy utility
+scipy.optimize.curve_fit to compute the Fisher Information Matrix (FIM) of
+parameter fits. SciPy is compatibly licensed.
+
+Name: scipy.optimize.curve_fit
+Files: src/prisma/nlr/nlr_parameter_fit_lib.py
+License: BSD-3-Clause
+  For details, see src/prisma/nlr/SciPy/LICENSE.txt

prisma_oed-0.0.1/PKG-INFO

@@ -0,0 +1,97 @@
+Metadata-Version: 2.4
+Name: prisma-oed
+Version: 0.0.1
+Summary: PRISMA (Physics-informed Regression and Inference for Statistics-driven Measurement Acquisition) is a Bayesian online nonlinear regression algorithm for active learning and SOED in spectroscopy experiments.
+Author: Xavier Tricoche, Andy Mounce, Sam Lilak, Devika Mehta, Leo Diaz, Luca Basso, Ezra Bussmann
+Author-email: Dante Basile <dbasile@purdue.edu>
+License-Expression: BSD-3-Clause
+Project-URL: Repository, https://github.com/sandialabs/PRISMA.git
+Keywords: machine learning,ML,Bayesian,nonlinear regression,spectroscopy,curve fitting,online learning,active learning,optimal experimental design,OED,sequential optimal experimental design,SOED,instrument control,real-time control,JAX
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Jupyter
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+License-File: LICENSES_bundled.txt
+Requires-Dist: ipykernel>=6.29
+Requires-Dist: jax>=0.6
+Requires-Dist: line_profiler>=4.2
+Requires-Dist: matplotlib>=3.10
+Requires-Dist: nanonis_spm>=1.0
+Requires-Dist: numpy>=2.3
+Requires-Dist: scipy>=1.15
+Dynamic: license-file
+
+# PRISMA
+
+PRISMA: Physics-informed Regression and Inference for Statistics-driven Measurement Acquisition
+
+## Description
+
+PRISMA is a Bayesian active learning algorithm that automates and optimizes
+spectroscopy measurements. PRISMA uses prior parameter distributions and known
+physics model equations to optimize measurement acquisition and fit model
+parameters in real-time. Active learning increases the speed and accuracy of
+spectroscopy measurements while maintaining confidence and rigor.
+
+## Authors and acknowledgment
+
+Developed by Dante Basile, Xavier Tricoche, Sam Lilak, Devika Mehta, Leo Diaz, Luca Basso, Andy Mounce, and Ezra Bussmann.
+
+This software was developed as part of work at the CINT (Center for Integrated Nanotechnologies), an Office of Science User Facility operated for the U.S. Department of Energy.
+
+## Installation
+
+Install in editable mode for development:
+
+```bash
+python3 -m pip install -e .
+```
+
+Install from `requirements.txt` for reproducible environment:
+
+```bash
+python3 -m pip install -r requirements.txt
+```
+
+## Usage
+
+Examples of PRISMA-directed spectroscopy experiments can be found in the
+`experiments` folder. These Jupyter notebooks show how to use
+PRISMA with both pseudorandom simulated data and instrument measurements.
+
+As a general overview, PRISMA defines the Bayesian online nonlinear regression
+algorithm in the `ActiveParameterFit` abstract base class in
+`src/prisma/apf/active_parameter_fit.py`. Subclasses implement this interface
+by implementing the `acquisition_f` abstract method with their acquisition
+function of choice to define their sampling strategy. For example,
+`ActiveParameterFitSigmaSqPred` samples at the maximum of the predictive
+variance and can be imported in the API at
+`prisma.apf.ActiveParameterFitSigmaSqPred`.
+
+Sampler classes in `src/prisma/samplers` provide drivers that allow PRISMA to acquire measurements
+at the domain values it specifies.
+
+Call the `fit` method of an initialized `ActiveParameterFit` instance to
+run PRISMA's active learning algorithm. This will optimize measurement
+acquisitions and fit model parameters.
+
+## License
+
+[BSD-3-Clause](https://opensource.org/license/bsd-3-clause)
+
+## Citation
+
+```bibtex
+@software{prisma2026github,
+  author = {Dante Basile and Xavier Tricoche and Sam Lilak and Devika Mehta and Leo Diaz and Luca Basso and Andy Mounce and Ezra Bussmann},
+  title = {{PRISMA}: {P}hysics-informed {R}egression and {I}nference for {S}tatistics-driven {M}easurement {A}cquisition},
+  url = {https://github.com/sandialabs/PRISMA},
+  version = {0.0.1},
+  year = {2026},
+}
+```

prisma_oed-0.0.1/README.md

@@ -0,0 +1,69 @@
+# PRISMA
+
+PRISMA: Physics-informed Regression and Inference for Statistics-driven Measurement Acquisition
+
+## Description
+
+PRISMA is a Bayesian active learning algorithm that automates and optimizes
+spectroscopy measurements. PRISMA uses prior parameter distributions and known
+physics model equations to optimize measurement acquisition and fit model
+parameters in real-time. Active learning increases the speed and accuracy of
+spectroscopy measurements while maintaining confidence and rigor.
+
+## Authors and acknowledgment
+
+Developed by Dante Basile, Xavier Tricoche, Sam Lilak, Devika Mehta, Leo Diaz, Luca Basso, Andy Mounce, and Ezra Bussmann.
+
+This software was developed as part of work at the CINT (Center for Integrated Nanotechnologies), an Office of Science User Facility operated for the U.S. Department of Energy.
+
+## Installation
+
+Install in editable mode for development:
+
+```bash
+python3 -m pip install -e .
+```
+
+Install from `requirements.txt` for reproducible environment:
+
+```bash
+python3 -m pip install -r requirements.txt
+```
+
+## Usage
+
+Examples of PRISMA-directed spectroscopy experiments can be found in the
+`experiments` folder. These Jupyter notebooks show how to use
+PRISMA with both pseudorandom simulated data and instrument measurements.
+
+As a general overview, PRISMA defines the Bayesian online nonlinear regression
+algorithm in the `ActiveParameterFit` abstract base class in
+`src/prisma/apf/active_parameter_fit.py`. Subclasses implement this interface
+by implementing the `acquisition_f` abstract method with their acquisition
+function of choice to define their sampling strategy. For example,
+`ActiveParameterFitSigmaSqPred` samples at the maximum of the predictive
+variance and can be imported in the API at
+`prisma.apf.ActiveParameterFitSigmaSqPred`.
+
+Sampler classes in `src/prisma/samplers` provide drivers that allow PRISMA to acquire measurements
+at the domain values it specifies.
+
+Call the `fit` method of an initialized `ActiveParameterFit` instance to
+run PRISMA's active learning algorithm. This will optimize measurement
+acquisitions and fit model parameters.
+
+## License
+
+[BSD-3-Clause](https://opensource.org/license/bsd-3-clause)
+
+## Citation
+
+```bibtex
+@software{prisma2026github,
+  author = {Dante Basile and Xavier Tricoche and Sam Lilak and Devika Mehta and Leo Diaz and Luca Basso and Andy Mounce and Ezra Bussmann},
+  title = {{PRISMA}: {P}hysics-informed {R}egression and {I}nference for {S}tatistics-driven {M}easurement {A}cquisition},
+  url = {https://github.com/sandialabs/PRISMA},
+  version = {0.0.1},
+  year = {2026},
+}
+```

prisma_oed-0.0.1/pyproject.toml

@@ -0,0 +1,63 @@
+[build-system]
+requires = ["setuptools >= 77.0.3"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "prisma-oed"
+version = "0.0.1"
+dependencies = [
+  "ipykernel >= 6.29",
+  "jax >= 0.6",
+  "line_profiler >= 4.2",
+  "matplotlib >= 3.10",
+  "nanonis_spm >= 1.0",
+  "numpy >= 2.3",
+  "scipy >= 1.15",
+]
+requires-python = ">= 3.13"
+authors = [
+  { name="Dante Basile", email="dbasile@purdue.edu" },
+  { name="Xavier Tricoche" },
+  { name="Andy Mounce" },
+  { name="Sam Lilak" },
+  { name="Devika Mehta" },
+  { name="Leo Diaz" },
+  { name="Luca Basso" },
+  { name="Ezra Bussmann" },
+]
+description = """\
+PRISMA (Physics-informed Regression and Inference for Statistics-driven \
+Measurement Acquisition) is a Bayesian online nonlinear regression algorithm \
+for active learning and SOED in spectroscopy experiments.\
+"""
+readme = "README.md"
+license = "BSD-3-Clause"
+license-files = ["LICEN[CS]E*"]
+keywords = [
+  "machine learning",
+  "ML",
+  "Bayesian",
+  "nonlinear regression",
+  "spectroscopy",
+  "curve fitting",
+  "online learning",
+  "active learning",
+  "optimal experimental design",
+  "OED",
+  "sequential optimal experimental design",
+  "SOED",
+  "instrument control",
+  "real-time control",
+  "JAX",
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+  "Development Status :: 4 - Beta",
+  "Framework :: Jupyter",
+  "Intended Audience :: Science/Research",
+  "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[project.urls]
+Repository = "https://github.com/sandialabs/PRISMA.git"

prisma_oed-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

prisma_oed-0.0.1/src/prisma/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.0.1'

prisma_oed-0.0.1/src/prisma/apf/api/__init__.py

@@ -0,0 +1,7 @@
+from .active_parameter_fit import ActiveParameterFitSigmaSqPred, \
+    ActiveParameterFitRP, ActiveParameterFitEI, \
+    AbstractActiveParameterFit
+
+__all__ = ['ActiveParameterFitSigmaSqPred', 'ActiveParameterFitRP',
+           'ActiveParameterFitEI',
+           'AbstractActiveParameterFit']

prisma_oed-0.0.1/src/prisma/apf/api/active_parameter_fit.py

@@ -0,0 +1,182 @@
+from abc import ABC, abstractmethod
+import jax
+import jax.numpy as jnp
+from jax.stages import Wrapped
+import numpy as np
+from numpy.typing import ArrayLike
+
+from ..util.active_parameter_fit_jax_lib import get_nonlin_f_x_j, \
+    acq_f_sigma_sq_predictive_j, acq_f_rp_j, \
+    acq_f_ei_j, \
+    init_arr_j, init_arr_rp_j, init_arr_ei_j, \
+    posterior_update_j
+from prisma.file import save_np_val
+from prisma.plot import plot_predictive_train_iter, \
+    plot_acq_train_iter, plot_predictive_acq_train_iter, plot_w_rmse, \
+    plot_w_i_err, plot_predictive_rmse
+from prisma.samplers.abstract import AbstractDomainSampler
+
+
+class AbstractActiveParameterFit(ABC):
+
+    def __init__(self, nonlin_f_j: Wrapped, acq_domain: ArrayLike,
+                 t_sampler: AbstractDomainSampler,
+                 beta: float, m_0: ArrayLike, S_0: ArrayLike,
+                 sample_ct: int):
+        # TODO: initialize all jit argument vars as jnp
+        self.nonlin_f_j = nonlin_f_j
+        self.acq_domain = acq_domain
+        self.t_sampler = t_sampler
+        self.beta = beta
+        self.param_ct = len(m_0)
+        self.sample_ct = sample_ct
+        self.acq_domain_len = len(acq_domain)
+        self.nonlin_f_j_N = get_nonlin_f_x_j(nonlin_f_j, acq_domain)
+        self.x_n_jnp, self.t_n_jnp, self.phi_n_jnp, \
+            self.m_prior_jnp, self.var_prior_jnp, self.acq_val_jnp \
+            = init_arr_j(m_0, S_0, self.param_ct, sample_ct,
+                         self.acq_domain_len)
+        self.x_n_np = self.t_n_np = self.phi_n_np \
+            = self.m_prior_np = self.var_prior_np = self.acq_val_np = None
+
+    def fit(self):
+        for i in range(self.sample_ct):
+            x_next, acq_val_next = self._acquisition_f(i)
+            t_next = self.t_sampler.sample(x_next)
+            self.x_n_jnp, self.t_n_jnp, self.acq_val_jnp, \
+                self.phi_n_jnp, self.m_prior_jnp, self.var_prior_jnp \
+                = posterior_update_j(x_next, acq_val_next, t_next,
+                                     self.nonlin_f_j, self.beta,
+                                     i, self.x_n_jnp, self.t_n_jnp,
+                                     self.phi_n_jnp, self.m_prior_jnp,
+                                     self.var_prior_jnp, self.acq_val_jnp)
+
+    def fit_sampler_reset(self):
+        self.t_sampler.reset()
+        self.fit()
+
+    def init_np_arrs(self):
+        self.x_n_np, self.t_n_np, self.phi_n_np, \
+            self.m_prior_np, self.var_prior_np, self.acq_val_np \
+            = self._jax_arrs_to_np_arrs(self.x_n_jnp, self.t_n_jnp,
+                                        self.phi_n_jnp, self.m_prior_jnp,
+                                        self.var_prior_jnp, self.acq_val_jnp)
+
+    def save_np_arrs(self, save_dir):
+        save_np_val(save_dir, "x_n.npy", self.x_n_np)
+        save_np_val(save_dir, "t_n.npy", self.t_n_np)
+        save_np_val(save_dir, "phi_n.npy", self.phi_n_np)
+        save_np_val(save_dir, "m_prior.npy", self.m_prior_np)
+        save_np_val(save_dir, "var_prior.npy", self.var_prior_np)
+        save_np_val(save_dir, "acq_n.npy", self.acq_val_np)
+
+    def plot_predictive_train_iter(self, y=None, title=True,
+                                   title_samples=False):
+        plot_predictive_train_iter(self.nonlin_f_j, self.acq_domain,
+                                   self.beta, self.m_prior_jnp,
+                                   self.var_prior_jnp,
+                                   y=y,
+                                   x_n=self.x_n_jnp, t_n=self.t_n_jnp,
+                                   title=title, title_samples=title_samples)
+
+    def plot_acq_train_iter(self):
+        plot_acq_train_iter(self.acq_domain, self.acq_val_jnp)
+
+    def plot_predictive_acq_train_iter(self, y=None, title=True,
+                                       title_samples=False):
+        plot_predictive_acq_train_iter(self.nonlin_f_j, self.acq_domain,
+                                       self.beta, self.m_prior_jnp,
+                                       self.var_prior_jnp,
+                                       self.acq_val_jnp,
+                                       y=y,
+                                       x_n=self.x_n_jnp, t_n=self.t_n_jnp,
+                                       title=title,
+                                       title_samples=title_samples)
+
+    def plot_w_rmse(self, w_act):
+        plot_w_rmse(w_act, m_N_l=self.m_prior_jnp)
+
+    def plot_w_i_err(self, w_act, i, w_i_name=None):
+        plot_w_i_err(w_act, i, m_N_l=self.m_prior_jnp, w_i_name=w_i_name)
+
+    def plot_predictive_rmse(self, t, y):
+        plot_predictive_rmse(self.nonlin_f_j, self.acq_domain, t, y,
+                             m_N_l=self.m_prior_jnp)
+
+    @abstractmethod
+    def _acquisition_f(self, i):
+        ...
+
+    def _jax_arrs_to_np_arrs(self, *jax_arrs):
+        return tuple(map(np.array, jax_arrs))
+
+
+class ActiveParameterFitSigmaSqPred(AbstractActiveParameterFit):
+    '''
+    Predictive variance
+    '''
+
+    def _acquisition_f(self, i):
+        x_next, acq = acq_f_sigma_sq_predictive_j(self.nonlin_f_j_N,
+                                                  self.acq_domain,
+                                                  self.beta, i,
+                                                  self.m_prior_jnp,
+                                                  self.var_prior_jnp)
+        return x_next, acq
+
+
+class ActiveParameterFitRP(AbstractActiveParameterFit):
+    '''
+    Normal repulsion
+    '''
+
+    def __init__(self, nonlin_f_j: Wrapped, acq_domain: ArrayLike,
+                 t_sampler: AbstractDomainSampler,
+                 beta: float, m_0: ArrayLike, S_0: ArrayLike,
+                 sample_ct: int,
+                 magnitude_rp: float, scale_rp: float):
+        super().__init__(nonlin_f_j, acq_domain, t_sampler, beta, m_0, S_0,
+                         sample_ct)
+        self.mag_rp = magnitude_rp
+        self.scl_rp = scale_rp
+        self.rp_jnp = init_arr_rp_j(self.acq_domain_len)
+
+    def _acquisition_f(self, i):
+        x_next, acq, rp_next = acq_f_rp_j(self.nonlin_f_j_N, self.acq_domain,
+                                          self.beta, i,
+                                          self.m_prior_jnp, self.var_prior_jnp,
+                                          self.mag_rp, self.scl_rp,
+                                          self.rp_jnp)
+        self.rp_jnp = rp_next
+        return x_next, acq
+
+
+class ActiveParameterFitEI(AbstractActiveParameterFit):
+    '''
+    Expected Improvement
+    '''
+
+    def __init__(self, nonlin_f_j: Wrapped, acq_domain: ArrayLike,
+                 t_sampler: AbstractDomainSampler,
+                 beta: float, m_0: ArrayLike, S_0: ArrayLike,
+                 sample_ct: int,
+                 range_delta: ArrayLike,
+                 m_mask: ArrayLike | None = None):
+        super().__init__(nonlin_f_j, acq_domain, t_sampler, beta, m_0, S_0,
+                         sample_ct)
+        if m_mask is None:
+            m_mask = np.ones(self.param_ct)
+        if jax.config.read('jax_enable_x64'):
+            self.eps_j = jnp.finfo(jnp.float64).eps
+        else:
+            self.eps_j = jnp.finfo(jnp.float32).eps
+        self.m_mask_jnp, self.range_delta_jnp = init_arr_ei_j(m_mask,
+                                                              range_delta)
+
+    def _acquisition_f(self, i):
+        x_next, acq, = acq_f_ei_j(self.nonlin_f_j_N, self.nonlin_f_j,
+                                  self.acq_domain, self.beta, i,
+                                  self.m_prior_jnp, self.var_prior_jnp,
+                                  self.range_delta_jnp, self.m_mask_jnp,
+                                  self.eps_j)
+        return x_next, acq