CUQIpy 1.3.0.post0.dev298__py3-none-any.whl → 1.4.0.post0.dev92__py3-none-any.whl

{cuqipy-1.3.0.post0.dev298.dist-info → cuqipy-1.4.0.post0.dev92.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.3.0.post0.dev298
+Version: 1.4.0.post0.dev92
 Summary: Computational Uncertainty Quantification for Inverse problems in Python
 Maintainer-email: "Nicolai A. B. Riis" <nabr@dtu.dk>, "Jakob S. Jørgensen" <jakj@dtu.dk>, "Amal M. Alghamdi" <amaal@dtu.dk>, Chao Zhang <chaz@dtu.dk>
 License:                                  Apache License

cuqipy-1.4.0.post0.dev92.dist-info/RECORD

@@ -0,0 +1,101 @@
+cuqi/__init__.py,sha256=gs3F4QTPPvZe1sGbPcHn9U4eIyYJHXCJuwK4-eLe0qs,531
+cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
+cuqi/_version.py,sha256=THAxuqXPxO5VvVxshGbGP7u9M3U8CCa9aQarrDWeJDw,509
+cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
+cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
+cuqi/algebra/__init__.py,sha256=2uWq2_H1XpXg1TLheTzLL3ySG5tFiNQkZCd9TcZeaEI,99
+cuqi/algebra/_abstract_syntax_tree.py,sha256=PdPz19cJMjvnMx4KEzhn4gvxIZX_UViE33Mbttj_5Xw,9873
+cuqi/algebra/_ordered_set.py,sha256=fKysh4pmI4xF7Y5Z6O86ABzg20o4uBs-v8jmLBMrdpo,2849
+cuqi/algebra/_random_variable.py,sha256=owEkaiF1lD0UUGLS9BOTsLKxL98NRTtmNnyVd9J0Y94,19717
+cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
+cuqi/array/_array.py,sha256=UJoWyQjDpl8g2q4wuuz_ufpr2JoYL0BbCxrxZpZR99I,4303
+cuqi/data/__init__.py,sha256=1aGgPmtG_Kqbb880vLnPksGvyYQB_6o2mz_q-4KGYaU,173
+cuqi/data/_data.py,sha256=PgdYJ6MHgNY37Ak8wUYwvxcAwOYSNjnf1-BXMdbnuv4,10716
+cuqi/data/astronaut.npz,sha256=vVTb6eJLMZhrEZuOYzQWN3V2EhhVH6sHzrrf_7mstcw,786696
+cuqi/data/camera.npz,sha256=EznyKfAomn4orm-L9gqM3QDFNuGB5XZwpZZMwDgiMKk,262408
+cuqi/data/cat.npz,sha256=9H9iJqkvlCCVZZ2IWMfwwfVHbShpQTkZo_WGr7rrp3k,406164
+cuqi/data/cookie.png,sha256=mr6wUeoIUc5VC2qYj8vafOmTbcRwz0fHz4IIPK9_PnE,984680
+cuqi/data/satellite.mat,sha256=a0Nz_Ak-Y0m360dH74pa_rpk-MhaQ91ftGTKhQX7I8g,16373
+cuqi/density/__init__.py,sha256=0zfVcPgqdqiPkss5n_WP_PUt-G3ovHXjokhqEKIlLwA,48
+cuqi/density/_density.py,sha256=Pfcq8b9MuTAuXxVwORRyNru_KIAFN1yHp2Y1yNwdyrg,7467
+cuqi/distribution/__init__.py,sha256=f-HM-SUrvPO66_FAJ6k4TffBq4H94OusRMDOJgcJU2w,779
+cuqi/distribution/_beta.py,sha256=QlibnuHNcvWjl-du5aRc9QuzS3n4PsyD_8Nc47w-E0Q,2903
+cuqi/distribution/_cauchy.py,sha256=Qwi21WkwUBnBkLbhR-yCGO0tQ_U_3mmvR0pDMPPPB5c,3296
+cuqi/distribution/_cmrf.py,sha256=tCbEulM_O7FB3C_W-3IqZp9zGHkTofCdFF0ybHc9UZI,3745
+cuqi/distribution/_custom.py,sha256=11lnAG7CS15bpV6JOOP--2YyKnAduvXY1IjAOJ1tqO0,10504
+cuqi/distribution/_distribution.py,sha256=ZT8k0J-DNoEptdVBbsTYHBBd17V-6DfCBwo1BatC_0Y,18277
+cuqi/distribution/_gamma.py,sha256=VcvBJS51N-MxuX42r9L2j2QYRlzhdgAtQ6Wa5IFO_YE,3536
+cuqi/distribution/_gaussian.py,sha256=3L1L_3W6i6YuPQ8vnFmju5QsvkLlg4VsgCnj11lYBUE,32977
+cuqi/distribution/_gmrf.py,sha256=OwId8qQWEtmC2fxVhL4iBHZnc8ZCrZzfV6yGXDE3k30,9522
+cuqi/distribution/_inverse_gamma.py,sha256=oPJuiYp3O1m547pmmIz9OWesky9YpwLTHT7-9MmcYss,3159
+cuqi/distribution/_joint_distribution.py,sha256=WoiaaZ_4nLFJaKUy-Ks5U0ED4DGb3BCKChcuCqJPCgU,20357
+cuqi/distribution/_laplace.py,sha256=5exLvlzJm2AgfvZ3KUSkjfwlGwwbsktBxP8z0iLMik8,1401
+cuqi/distribution/_lmrf.py,sha256=rdGoQ-fPe1oW6Z29P-l3woq0NX3_RxUQ2rzm1VzemNM,3290
+cuqi/distribution/_lognormal.py,sha256=8_hOFQ3iu88ujX8vxmfVEZ0fdmlhTY98PlG5PasPjEg,2612
+cuqi/distribution/_modifiedhalfnormal.py,sha256=ErULXUFRjbMyCYywaOzfuxtoy-XQmC0McMROo2mTQtc,7313
+cuqi/distribution/_normal.py,sha256=vhIiAseW09IKh1uy0KUq7RP1IuY7hH5aNM1W_R8Gd_Q,2912
+cuqi/distribution/_posterior.py,sha256=6LxXAIBzFxyEqx5bUfgqTXVKgXxqNhRItec6FcRVLEE,5350
+cuqi/distribution/_smoothed_laplace.py,sha256=p-1Y23mYA9omwiHGkEuv3T2mwcPAAoNlCr7T8osNkjE,2925
+cuqi/distribution/_truncated_normal.py,sha256=_ez3MmO6qpBeP6BKCUlW3IgxuF7k--A7jPGPUhtYK0g,4240
+cuqi/distribution/_uniform.py,sha256=fVgj_4SBav8JMc1pNAO1l_CZ9ZwdoMIpN9iQ3i9_Z0Q,3255
+cuqi/experimental/__init__.py,sha256=OZ4WHvYNiQWGdRikzSDhDZcajr9ib35NblQpIOHnQCg,109
+cuqi/experimental/_recommender.py,sha256=ulW69nDGwkB8X93OMgMVLcVz2L0T3SZqHKG7jZ9wNm8,7907
+cuqi/geometry/__init__.py,sha256=1BcuUHP5tNzfsTLz1qB0WACRIVJU3AtdgfEqgI89oo8,891
+cuqi/geometry/_geometry.py,sha256=W-oQTZPelVS7fN9qZj6bNBuh-yY0eqOHJ39UwB-WmQY,47562
+cuqi/geometry/_product_geometry.py,sha256=tdFUrQzoKPtqbd5aLxXP3DMOkBNrM9B-DTUQPNBxgFE,7186
+cuqi/implicitprior/__init__.py,sha256=6Fl4Lmld8ikg9sW9tReKRGTCJC6_WCTExHaYuIv34nM,323
+cuqi/implicitprior/_regularizedGMRF.py,sha256=BUeT4rwJzary9K56fkxCNGCeKZd-2VSgOT8XNHxFPRE,6345
+cuqi/implicitprior/_regularizedGaussian.py,sha256=9BSKHGEW0OT9OIt_42strDzxBM8mB6A-blcf0kEguHw,21836
+cuqi/implicitprior/_regularizedUnboundedUniform.py,sha256=uHGYYnTjVxdPbY-5JwocFOH0sHRfGrrLiHWahzH9R8A,3533
+cuqi/implicitprior/_restorator.py,sha256=KxaC5QHdu8mTXJnOAVIBqe7-6D58sGKbKhDobyrYosA,11569
+cuqi/legacy/__init__.py,sha256=KEIAkfTQUW7CM7ekOVRAD6E7QGwehHN5bBlfGxByttQ,106
+cuqi/legacy/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
+cuqi/legacy/sampler/_conjugate.py,sha256=x5OsFk1zDm2tvoFsSxbCKwjSqBHUGbcUvcTwDOvL-tw,2841
+cuqi/legacy/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
+cuqi/legacy/sampler/_cwmh.py,sha256=xft9_oEh52W5GpnnDK8ZRK--RseymINQlYLhYdtRNnk,7789
+cuqi/legacy/sampler/_gibbs.py,sha256=1UItwYlj17JcJhqCYCfDw1x39o82Y1q9ykJ6zG19ppE,8965
+cuqi/legacy/sampler/_hmc.py,sha256=6fSWjDLZcZH28X21h9Uq9RhgKGXUOamy-2wqJ_WR-qc,15041
+cuqi/legacy/sampler/_langevin_algorithm.py,sha256=JknIc9k68JYcQz601ald6yNTtE7ILw-shxx7X0_fGUI,7882
+cuqi/legacy/sampler/_laplace_approximation.py,sha256=CvMQmMxi_XmaIdWrs9tsu4NTty7uSm4jIlb_zrQaW0w,6572
+cuqi/legacy/sampler/_mh.py,sha256=hmNfEBUihDHE2g4wKkwxUEuPj_1at7Mrpt2w9OMHX0M,7076
+cuqi/legacy/sampler/_pcn.py,sha256=PlMGwsI0ZCDfrAT95u-5uvdYdD2lkaLhnQZCsBFl_Y0,8622
+cuqi/legacy/sampler/_rto.py,sha256=bfVKgk-2NnrkTnRaZvs2zIfiWSbElIYx0zaMu6lab-s,11935
+cuqi/legacy/sampler/_sampler.py,sha256=hw5BNhnFkERGtdvZ4Gd_QQZYshNiU_Jx-Yl1--x5HAs,6023
+cuqi/likelihood/__init__.py,sha256=QXif382iwZ5bT3ZUqmMs_n70JVbbjxbqMrlQYbMn4Zo,1776
+cuqi/likelihood/_likelihood.py,sha256=I12qQF3h_Z8jj7zb_AYD-SEUn34VCU7VxcTcH25Axao,7074
+cuqi/model/__init__.py,sha256=jgY2-jyxEMC79vkyH9BpfowW7_DbMRjqedOtO5fykXQ,62
+cuqi/model/_model.py,sha256=SWGCzZ2-rmosngulNOofgyMC1K3-WmDH3_Ws3qs8Pmg,74912
+cuqi/operator/__init__.py,sha256=0pc9p-KPyl7KtPV0noB0ddI0CP2iYEHw5rbw49D8Njk,136
+cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,8856
+cuqi/pde/__init__.py,sha256=pExaUnEvdNtgL9sQachcKkbDilE87rRiUTKk4hd2zSM,158
+cuqi/pde/_observation_map.py,sha256=0WbGkxukE9PNMnQNkFoeAdKBSzhnnzOrDiqh59tjsMY,1407
+cuqi/pde/_pde.py,sha256=voneMZcSv4kX-SMsIOhRLIrB_LYEXu0-Ex-Ivt3BTMs,17764
+cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
+cuqi/problem/_problem.py,sha256=8pq9z0VguW1vIJj35msGG1KdCI7gDb7-fEq59mNbsUI,38577
+cuqi/sampler/__init__.py,sha256=7H8gmUJ6Woezc6RcXj1nARt8CF59ILeOxryQr9li9jU,4616
+cuqi/sampler/_conjugate.py,sha256=QeQI-ZH4OK_wIIygWLM7dNkH0TSVixdb-VUBFc2prw4,22049
+cuqi/sampler/_conjugate_approx.py,sha256=LXPykdG-2KKCCIsxeu4G4Iu6BcAtujtAVOJTGV_aRbc,3525
+cuqi/sampler/_cwmh.py,sha256=0CVKuFuD5-99ipXF-EQ5T5RpYORWriugzttNu6xM7Ik,7320
+cuqi/sampler/_direct.py,sha256=tyVoC9lOGrdR4T0bQUlRewC8uDaenIV61Jk3NEttVVw,767
+cuqi/sampler/_gibbs.py,sha256=8V5yBEmBsjiUTVKPTd8nT94AJ4hMraI6LitDDqv7Nrg,14405
+cuqi/sampler/_hmc.py,sha256=yQ0mq51sRMLICRXIdDZLNzlJLt-03OecDOsMkADb-sI,19462
+cuqi/sampler/_langevin_algorithm.py,sha256=2FubHq6p5MruHx8hwLRQXHoHqf5POO4JR6UAkBWV6r4,15029
+cuqi/sampler/_laplace_approximation.py,sha256=tfsfbHhMA_q0pcNF5X8SYT6bWWzY5BSC-hKKRdSaGUI,5906
+cuqi/sampler/_mh.py,sha256=WsVmpvkhvYuFoUvXevOYibIwmhvaKY4YXrkEsF_5YvY,2931
+cuqi/sampler/_pcn.py,sha256=C8JzklKRXrF-XjEGjyMJ12gZS1ufxQwkTOvhcXlHdZc,3470
+cuqi/sampler/_rto.py,sha256=AQFi8Kqa3uQZsZxdpPb2B9Is_lyfz1v8l9JAY3e4J2w,17186
+cuqi/sampler/_sampler.py,sha256=rwlaidODyOcG3RQIOaFkPwk0aLZAXdw-3xA35izNgqQ,21022
+cuqi/samples/__init__.py,sha256=vCs6lVk-pi8RBqa6cIN5wyn6u-K9oEf1Na4k1ZMrYv8,44
+cuqi/samples/_samples.py,sha256=hUc8OnCF9CTCuDTrGHwwzv3wp8mG_6vsJAFvuQ-x0uA,35832
+cuqi/solver/__init__.py,sha256=KYgAi_8VoAwljTB3S2I87YnJkRtedskLee7hQp_-zp8,220
+cuqi/solver/_solver.py,sha256=X3EWD-26o9UOBsWRuy0ktYsJiUXwpCGm0lvTdQM6dRI,30964
+cuqi/testproblem/__init__.py,sha256=DWTOcyuNHMbhEuuWlY5CkYkNDSAqhvsKmJXBLivyblU,202
+cuqi/testproblem/_testproblem.py,sha256=EJWG_zXUtmo6GlHBZFqHlRpDC_48tE0XZEu0_C66NS8,52524
+cuqi/utilities/__init__.py,sha256=d5QXRzmI6EchS9T4b7eTezSisPWuWklO8ey4YBx9kI0,569
+cuqi/utilities/_get_python_variable_name.py,sha256=wxpCaj9f3ZtBNqlGmmuGiITgBaTsY-r94lUIlK6UAU4,2043
+cuqi/utilities/_utilities.py,sha256=R7BdNysrE36a4D729DvfrTisWY4paP5nfqdkQxSX3Mg,18431
+cuqipy-1.4.0.post0.dev92.dist-info/licenses/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+cuqipy-1.4.0.post0.dev92.dist-info/METADATA,sha256=O6rws-Zn0aPz13jiQkcpRcXcA5HQV2fRG54KOpAwr4Y,18623
+cuqipy-1.4.0.post0.dev92.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cuqipy-1.4.0.post0.dev92.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+cuqipy-1.4.0.post0.dev92.dist-info/RECORD,,

cuqi/experimental/algebra/__init__.py

@@ -1,2 +0,0 @@
-from ._ast import VariableNode, Node
-from ._randomvariable import RandomVariable

cuqi/experimental/geometry/__init__.py

@@ -1 +0,0 @@
-from ._productgeometry import _ProductGeometry

cuqi/experimental/mcmc/__init__.py

@@ -1,122 +0,0 @@
-"""
-Re-implementation of sampler module in a more object-oriented way.
-
-Main changes for users
-----------------------
-
-1. Sampling API
-   ^^^^^^^^^^^^
-
-   Previously one would call the `.sample` or `sample_adapt` methods of a sampler instance at :py:mod:`cuqi.sampler` to sample from a target distribution and store the samples as the output as follows:
-
-   .. code-block:: python
-
-      from cuqi.sampler import MH
-      from cuqi.distribution import DistributionGallery
-
-      # Target distribution
-      target = DistributionGallery("donut")
-
-      # Set up sampler
-      sampler = MH(target)
-
-      # Sample from the target distribution (Alternatively calling sample with explicit scale parameter set in sampler)
-      samples = sampler.sample_adapt(Ns=100, Nb=100) # Burn-in (Nb) removed by default
-
-   This has now changed to to a more object-oriented API which provides more flexibility and control over the sampling process.
-
-   For example one can now more explicitly control when the sampler is tuned (warmup) and when it is sampling with fixed parameters.
-
-   .. code-block:: python
-
-      from cuqi.experimental.mcmc import MH
-      from cuqi.distribution import DistributionGallery
-
-      # Target distribution
-      target = DistributionGallery("donut")
-
-      # Set up sampler
-      sampler = MH(target)
-
-      # Sample from the target distribution
-      sampler.warmup(Nb=100)  # Explicit warmup (tuning) of sampler
-      sampler.sample(Ns=100)  # Sampling with fixed parameters
-      samples = sampler.get_samples().burnthin(Nb=100) # Getting samples and removing burn-in from warmup
-
-   Importantly, the removal of burn-in from e.g. warmup is now a separate step that is done after the sampling process is complete.
-
-2. Sampling API for BayesianProblem
-   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-   :py:class:`cuqi.problem.BayesianProblem` continues to have the same API for `sample_posterior` and the `UQ` method.
-
-   There is now a flag `experimental` that can be set to `True` to use the new MCMC samplers.
-   
-   By default, the flag is set to `False` and the old samplers are used.
-
-   For this more high-level interface, burn-in is automatically removed from the samples as was the case before.
-
-
-3. More options for Gibbs sampling
-   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-   There are now more options for Gibbs sampling. Previously it was only possible to sample with Gibbs for samplers  :py:class:`cuqi.sampler.LinearRTO`, :py:class:`cuqi.sampler.RegularizedLinearRTO`, :py:class:`cuqi.sampler.Conjugate`, and :py:class:`cuqi.sampler.ConjugateApprox`.
-
-   Now, it is possible to define a Gibbs sampling scheme using any sampler from the :py:mod:`cuqi.experimental.mcmc` module.
-
-   **Example using a NUTS-within-Gibbs scheme for a 1D deconvolution problem:**
-
-   .. code-block:: python
-
-      import cuqi
-      import numpy as np
-      from cuqi.distribution import Gamma, Gaussian, GMRF, JointDistribution
-      from cuqi.experimental.mcmc import NUTS, HybridGibbs, Conjugate
-      from cuqi.testproblem import Deconvolution1D
-
-      # Forward problem
-      A, y_data, info = Deconvolution1D(dim=128, phantom='sinc', noise_std=0.001).get_components()
-
-      # Bayesian Inverse Problem
-      s = Gamma(1, 1e-4)
-      x = GMRF(np.zeros(A.domain_dim), 50)
-      y = Gaussian(A @ x, lambda s: 1 / s)
-
-      # Posterior
-      target = JointDistribution(y, x, s)(y=y_data)
-
-      # Gibbs sampling strategy. Note we can define initial_points and various parameters for each sampler
-      sampling_strategy = {
-          "x": NUTS(max_depth=10, initial_point=np.zeros(A.domain_dim)),
-          "s": Conjugate()
-      }
-
-      # Here we do 10 internal steps with NUTS for each Gibbs step
-      num_sampling_steps = {
-          "x": 10,
-          "s": 1
-      }
-
-      sampler = HybridGibbs(target, sampling_strategy, num_sampling_steps)
-
-      sampler.warmup(50)
-      sampler.sample(200)
-      samples = sampler.get_samples().burnthin(Nb=50)
-
-      samples["x"].plot_ci(exact=info.exactSolution)
-"""
-
-
-
-from ._sampler import Sampler, ProposalBasedSampler
-from ._langevin_algorithm import ULA, MALA, MYULA, PnPULA
-from ._mh import MH
-from ._pcn import PCN
-from ._rto import LinearRTO, RegularizedLinearRTO
-from ._cwmh import CWMH
-from ._laplace_approximation import UGLA
-from ._hmc import NUTS
-from ._gibbs import HybridGibbs
-from ._conjugate import Conjugate
-from ._conjugate_approx import ConjugateApprox
-from ._direct import Direct

cuqi/experimental/mcmc/_conjugate.py

@@ -1,396 +0,0 @@
-import numpy as np
-from abc import ABC, abstractmethod
-import math
-from cuqi.experimental.mcmc import Sampler
-from cuqi.distribution import Posterior, Gaussian, Gamma, GMRF, ModifiedHalfNormal
-from cuqi.implicitprior import RegularizedGaussian, RegularizedGMRF, RegularizedUnboundedUniform
-from cuqi.utilities import get_non_default_args, count_nonzero, count_within_bounds, count_constant_components_1D, count_constant_components_2D, piecewise_linear_1D_DoF
-from cuqi.geometry import Continuous1D, Continuous2D, Image2D
-
-class Conjugate(Sampler):
-    """ Conjugate sampler
-
-    Sampler for sampling a posterior distribution which is a so-called "conjugate" distribution, i.e., where the likelihood and prior are conjugate to each other - denoted as a conjugate pair.   
-
-    Currently supported conjugate pairs are:
-    - (Gaussian, Gamma) where Gamma is defined on the precision parameter of the Gaussian
-    - (GMRF, Gamma) where Gamma is defined on the precision parameter of the GMRF
-    - (RegularizedGaussian, Gamma) with preset constraints only and Gamma is defined on the precision parameter of the RegularizedGaussian
-    - (RegularizedGMRF, Gamma) with preset constraints only and Gamma is defined on the precision parameter of the RegularizedGMRF
-    - (RegularizedGaussian, ModifiedHalfNormal) with most of the preset constraints and regularization
-    - (RegularizedGMRF, ModifiedHalfNormal) with most of the preset constraints and regularization
-
-    Currently the Gamma and ModifiedHalfNormal distribution must be univariate.
-
-    A conjugate pair defines implicitly a so-called conjugate distribution which can be sampled from directly.
-
-    The conjugate parameter is the parameter that both the likelihood and prior PDF depend on.
-
-    For more information on conjugacy and conjugate distributions see https://en.wikipedia.org/wiki/Conjugate_prior.
-
-    For implicit regularized Gaussians and the corresponding conjugacy relations, see:
-    
-    Section 3.3 from [1] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Bayesian inference with projected densities." SIAM/ASA Journal on Uncertainty Quantification 11.3 (2023): 1025-1043.
-    Section 4 from [2] Everink, Jasper M., Yiqiu Dong, and Martin S. Andersen. "Sparse Bayesian inference with regularized Gaussian distributions." Inverse Problems 39.11 (2023): 115004.
-
-    """
-
-    def _initialize(self):
-        pass
-
-    @Sampler.target.setter # Overwrite the target setter to set the conjugate pair
-    def target(self, value):
-        """ Set the target density. Runs validation of the target. """
-        self._target = value
-        if self._target is not None:
-            self._set_conjugatepair()
-            self.validate_target()
-
-    def validate_target(self):
-        self._ensure_target_is_posterior()
-        self._conjugatepair.validate_target()
-        
-    def step(self):
-        self.current_point = self._conjugatepair.sample()
-        return 1 # Returns acceptance rate of 1
-
-    def tune(self, skip_len, update_count):
-        pass # No tuning required for conjugate sampler
-
-    def _ensure_target_is_posterior(self):
-        """ Ensure that the target is a Posterior distribution. """
-        if not isinstance(self.target, Posterior):
-            raise TypeError("Conjugate sampler requires a target of type Posterior")
-
-    def _set_conjugatepair(self):
-        """ Set the conjugate pair based on the likelihood and prior. This requires target to be set. """
-        self._ensure_target_is_posterior()
-        if isinstance(self.target.likelihood.distribution, (Gaussian, GMRF)) and isinstance(self.target.prior, Gamma):
-            self._conjugatepair = _GaussianGammaPair(self.target)
-        elif isinstance(self.target.likelihood.distribution, RegularizedUnboundedUniform) and isinstance(self.target.prior, Gamma):
-            # Check RegularizedUnboundedUniform before RegularizedGaussian and RegularizedGMRF due to the first inheriting from the second.
-            self._conjugatepair = _RegularizedUnboundedUniformGammaPair(self.target)
-        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, Gamma):
-            self._conjugatepair = _RegularizedGaussianGammaPair(self.target)
-        elif isinstance(self.target.likelihood.distribution, (RegularizedGaussian, RegularizedGMRF)) and isinstance(self.target.prior, ModifiedHalfNormal):
-            self._conjugatepair = _RegularizedGaussianModifiedHalfNormalPair(self.target)
-        else:
-            raise ValueError(f"Conjugacy is not defined for likelihood {type(self.target.likelihood.distribution)} and prior {type(self.target.prior)}, in CUQIpy")
-
-    def conjugate_distribution(self):
-        return self._conjugatepair.conjugate_distribution()
-
-    def __repr__(self):
-        msg = super().__repr__()
-        if hasattr(self, "_conjugatepair"):
-            msg += f"\n Conjugate pair:\n\t {type(self._conjugatepair).__name__.removeprefix('_')}"
-        return msg
-        
-class _ConjugatePair(ABC):
-    """ Abstract base class for conjugate pairs (likelihood, prior) used in the Conjugate sampler. """
-
-    def __init__(self, target):
-        self.target = target
-
-    @abstractmethod
-    def validate_target(self):
-        """ Validate the target distribution for the conjugate pair. """
-        pass
-
-    @abstractmethod
-    def conjugate_distribution(self):
-        """ Returns the posterior distribution in the form of a CUQIpy distribution """
-        pass
-
-    def sample(self):
-        """ Sample from the conjugate distribution. """
-        return self.conjugate_distribution().sample()
-
-
-class _GaussianGammaPair(_ConjugatePair):
-    """ Implementation for the Gaussian-Gamma conjugate pair."""
-
-    def validate_target(self):
-        if self.target.prior.dim != 1:
-            raise ValueError("Gaussian-Gamma conjugacy only works with univariate Gamma prior")
-
-        key_value_pairs = _get_conjugate_parameter(self.target)
-        if len(key_value_pairs) != 1:
-            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
-        for key, value in key_value_pairs:
-            if key == "cov":
-                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
-                    raise ValueError("Gaussian-Gamma conjugate pair defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
-            elif key == "prec":
-                if not _check_conjugate_parameter_is_scalar_linear(value):
-                    raise ValueError("Gaussian-Gamma conjugate pair defined via precision requires prec: lambda x : s*x for the conjugate parameter")
-            else:
-                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
-
-    def conjugate_distribution(self):
-        # Extract variables
-        b = self.target.likelihood.data                                 # mu
-        m = len(b)                                                      # n
-        Ax = self.target.likelihood.distribution.mean                   # x_i
-        L = self.target.likelihood.distribution(np.array([1])).sqrtprec # L
-        alpha = self.target.prior.shape                                 # alpha
-        beta = self.target.prior.rate                                   # beta
-
-        # Create Gamma distribution and sample
-        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
-
-
-class _RegularizedGaussianGammaPair(_ConjugatePair):
-    """Implementation for the Regularized Gaussian-Gamma conjugate pair using the conjugacy rules from [1], Section 3.3."""
-
-    def validate_target(self):
-        if self.target.prior.dim != 1:
-            raise ValueError("RegularizedGaussian-Gamma conjugacy only works with univariate ModifiedHalfNormal prior")
-
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        key_value_pairs = _get_conjugate_parameter(self.target)
-        if len(key_value_pairs) != 1:
-            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
-        for key, value in key_value_pairs:
-            if key == "cov":
-                if not _check_conjugate_parameter_is_scalar_linear_reciprocal(value):
-                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
-            elif key == "prec":
-                if not _check_conjugate_parameter_is_scalar_linear(value):
-                    raise ValueError("Regularized Gaussian-Gamma conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
-            else:
-                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov and prec")
-
-    def conjugate_distribution(self):
-        # Extract variables
-        b = self.target.likelihood.data                                 # mu
-        m = _compute_sparsity_level(self.target)
-        Ax = self.target.likelihood.distribution.mean                   # x_i
-        L = self.target.likelihood.distribution(np.array([1])).sqrtprec # L
-        alpha = self.target.prior.shape                                 # alpha
-        beta = self.target.prior.rate                                   # beta
-
-        # Create Gamma distribution and sample
-        return Gamma(shape=m/2 + alpha, rate=.5 * np.linalg.norm(L @ (Ax - b))**2 + beta)
-    
-    
-class _RegularizedUnboundedUniformGammaPair(_ConjugatePair):
-    """Implementation for the RegularizedUnboundedUniform-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
-
-    def validate_target(self):
-        if self.target.prior.dim != 1:
-            raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy only works with univariate Gamma prior")
-        
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        key_value_pairs = _get_conjugate_parameter(self.target)
-        if len(key_value_pairs) != 1:
-            raise ValueError(f"Multiple references to conjugate parameter {self.target.prior.name} found in likelihood. Only one occurance is supported.")
-        for key, value in key_value_pairs:
-            if key == "strength":
-                if not _check_conjugate_parameter_is_scalar_linear(value):
-                    raise ValueError("RegularizedUnboundedUniform-Gamma conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
-            else:
-                raise ValueError(f"RegularizedUnboundedUniform-Gamma conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only strength is supported")
-
-    def conjugate_distribution(self):
-        # Extract prior variables
-        alpha = self.target.prior.shape
-        beta = self.target.prior.rate
-
-        # Compute likelihood quantities
-        x = self.target.likelihood.data
-        m = _compute_sparsity_level(self.target)
-
-        reg_op = self.target.likelihood.distribution._regularization_oper
-        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
-        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
-
-        # Create Gamma distribution
-        return Gamma(shape=m/2 + alpha, rate=fx + beta)
-    
-class _RegularizedGaussianModifiedHalfNormalPair(_ConjugatePair):
-    """Implementation for the Regularized Gaussian-ModifiedHalfNormal conjugate pair using the conjugacy rules from [2], Section 4."""
-
-    def validate_target(self):
-        if self.target.prior.dim != 1:
-            raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy only works with univariate ModifiedHalfNormal prior")
-        
-        # Raises error if preset is not supported
-        _compute_sparsity_level(self.target)
-
-        key_value_pairs = _get_conjugate_parameter(self.target)
-        if len(key_value_pairs) != 2:
-            raise ValueError(f"Incorrect number of references to conjugate parameter {self.target.prior.name} found in likelihood. Found {len(key_value_pairs)} times, but needs to occur in prec or cov, and in strength")
-        for key, value in key_value_pairs:
-            if key == "strength":
-                if not _check_conjugate_parameter_is_scalar_linear(value):
-                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via strength requires strength: lambda x : s*x for the conjugate parameter")
-            elif key == "prec":
-                if not _check_conjugate_parameter_is_scalar_quadratic(value):
-                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy defined via precision requires prec: lambda x : s*x for the conjugate parameter")
-            elif key == "cov":
-                if not _check_conjugate_parameter_is_scalar_quadratic_reciprocal(value):
-                    raise ValueError("RegularizedGaussian-ModifiedHalfNormal conjugacy  defined via covariance requires cov: lambda x : s/x for the conjugate parameter")
-            else:
-                raise ValueError(f"RegularizedGaussian-ModifiedHalfNormal conjugacy does not support the conjugate parameter {self.target.prior.name} in the {key} attribute. Only cov, prec and strength are supported")
-
-
-    def conjugate_distribution(self):
-        # Extract prior variables
-        alpha = self.target.prior.alpha
-        beta = self.target.prior.beta
-        gamma = self.target.prior.gamma
-
-        # Compute likelihood variables
-        x = self.target.likelihood.data
-        mu = self.target.likelihood.distribution.mean
-        L = self.target.likelihood.distribution(np.array([1])).sqrtprec
-        
-        m = _compute_sparsity_level(self.target)
-
-        reg_op = self.target.likelihood.distribution._regularization_oper
-        reg_strength = self.target.likelihood.distribution(np.array([1])).strength
-        fx = reg_strength*np.linalg.norm(reg_op@x, ord = 1)
-
-        # Compute parameters of conjugate distribution
-        conj_alpha = m + alpha
-        conj_beta = 0.5*np.linalg.norm(L @ (mu - x))**2 + beta
-        conj_gamma = -fx + gamma
-
-        # Create conjugate distribution
-        return ModifiedHalfNormal(conj_alpha, conj_beta, conj_gamma)
-    
-
-def _compute_sparsity_level(target):
-    """Computes the sparsity level in accordance with Section 4 from [2],
-    this can be interpreted as the number of degrees of freedom, that is,
-    the number of components n minus the dimension the of the subdifferential of the regularized.
-    """
-    x = target.likelihood.data
-
-    constraint = target.likelihood.distribution.preset["constraint"]
-    regularization = target.likelihood.distribution.preset["regularization"]
-
-    # There is no reference for some of these conjugacy rules
-    if constraint == "nonnegativity":
-        if regularization in [None, "l1"]:
-            # Number of non-zero components in x
-            return count_nonzero(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of non-zero constant components in x
-            return count_constant_components_1D(x, lower = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of non-zero constant components in x
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x), lower = 0.0)
-    elif constraint == "box":
-        bounds = target.likelihood.distribution._box_bounds
-        if regularization is None:
-            # Number of components in x that are strictly between the lower and upper bound
-            return count_within_bounds(x, bounds[0], bounds[1])
-        elif regularization == "l1":
-            # Number of components in x that are strictly between the lower and upper bound and are not zero
-            return count_within_bounds(x, bounds[0], bounds[1], exception = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of constant components in x between are strictly between the lower and upper bound
-            return count_constant_components_1D(x, lower = bounds[0], upper = bounds[1])
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of constant components in x between are strictly between the lower and upper bound
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x), lower = bounds[0], upper = bounds[1])
-    elif constraint in ["increasing", "decreasing"]:
-        if regularization is None:
-            # Number of constant components in x
-            return count_constant_components_1D(x)
-        elif regularization == "l1":
-            # Number of constant components in x that are not zero
-            return count_constant_components_1D(x, exception = 0.0)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of constant components in x
-            return count_constant_components_1D(x)
-        # Increasing and decreasing cannot be done in 2D
-    elif constraint in ["convex", "concave"]:
-        if regularization is None:
-            # Number of piecewise linear components in x
-            return piecewise_linear_1D_DoF(x)
-        elif regularization == "l1":
-            # Number of piecewise linear components in x that are not zero
-            return piecewise_linear_1D_DoF(x, exception_zero = True)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of piecewise linear components in x that are not flat
-            return piecewise_linear_1D_DoF(x, exception_flat = True)
-        # convex and concave has only been implemented in 1D
-    elif constraint == None: 
-        if regularization == "l1":
-            # Number of non-zero components in x
-            return count_nonzero(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, Continuous1D):
-            # Number of non-zero constant components in x
-            return count_constant_components_1D(x)
-        elif regularization == "tv" and isinstance(target.likelihood.distribution.geometry, (Continuous2D, Image2D)):
-            # Number of non-zero constant components in x
-            return count_constant_components_2D(target.likelihood.distribution.geometry.par2fun(x))
-
-    raise ValueError("RegularizedGaussian preset constraint and regularization choice is currently not supported with conjugacy.")
-
-
-def _get_conjugate_parameter(target):
-    """Extract the conjugate parameter name (e.g. d), and returns the mutable variable that is defined by the conjugate parameter, e.g. cov and its value e.g. lambda d:1/d"""
-    par_name = target.prior.name
-    mutable_likelihood_vars  = target.likelihood.distribution.get_mutable_variables()
-
-    found_parameter_pairs = []
-
-    for var_key in mutable_likelihood_vars:
-        attr = getattr(target.likelihood.distribution, var_key)
-        if callable(attr) and par_name in get_non_default_args(attr):
-            found_parameter_pairs.append((var_key, attr))
-    if len(found_parameter_pairs) == 0:
-        raise ValueError(f"Unable to find conjugate parameter {par_name} in likelihood function for conjugate sampler with target {target}")
-    return found_parameter_pairs
-
-def _check_conjugate_parameter_is_scalar_identity(f):
-    """Tests whether a function (scalar to scalar) is the identity (lambda x: x)."""
-    test_values = [1.0, 10.0, 100.0]
-    return all(np.allclose(f(x), x) for x in test_values)
-
-def _check_conjugate_parameter_is_scalar_reciprocal(f):
-    """Tests whether a function (scalar to scalar) is the reciprocal (lambda x : 1.0/x)."""
-    return all(math.isclose(f(x), 1.0 / x) for x in [1.0, 10.0, 100.0])
-
-def _check_conjugate_parameter_is_scalar_linear(f):
-    """
-        Tests whether a function (scalar to scalar) is linear (lambda x: s*x for some s).
-        The tests checks whether the function is zero and some finite differences are constant.
-    """
-    test_values = [1.0, 10.0, 100.0]
-    h = 1e-2
-    finite_diffs = [(f(x + h*x)-f(x))/(h*x) for x in test_values]
-    return np.isclose(f(0.0), 0.0) and all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
-
-def _check_conjugate_parameter_is_scalar_linear_reciprocal(f):
-    """
-        Tests whether a function (scalar to scalar) is a constant times the inverse of the input (lambda x: s/x for some s).
-        The tests checks whether the the reciprocal of the function has constant finite differences.
-    """
-    g = lambda x : 1.0/f(x)
-    test_values = [1.0, 10.0, 100.0]
-    h = 1e-2
-    finite_diffs = [(g(x + h*x)-g(x))/(h*x) for x in test_values]
-    return all(np.allclose(c, finite_diffs[0]) for c in finite_diffs[1:])
-
-def _check_conjugate_parameter_is_scalar_quadratic(f):
-    """
-        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**2 for some s).
-        The tests checks whether the function divided by the parameter is linear
-    """
-    return _check_conjugate_parameter_is_scalar_linear(lambda x: f(x)/x if x != 0.0 else f(0.0))
-
-def _check_conjugate_parameter_is_scalar_quadratic_reciprocal(f):
-    """
-        Tests whether a function (scalar to scalar) is linear (lambda x: s*x**-2 for some s).
-        The tests checks whether the function divided by the parameter is the reciprical of a linear function.
-    """
-    return _check_conjugate_parameter_is_scalar_linear_reciprocal(lambda x: f(x)/x)