CUQIpy 1.3.0.post0.dev401__py3-none-any.whl → 1.4.0.post0.dev41__py3-none-any.whl

{cuqipy-1.3.0.post0.dev401.dist-info → cuqipy-1.4.0.post0.dev41.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: CUQIpy
-Version: 1.3.0.post0.dev401
+Version: 1.4.0.post0.dev41
 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.3.0.post0.dev401.dist-info → cuqipy-1.4.0.post0.dev41.dist-info}/RECORD

@@ -1,6 +1,6 @@
-cuqi/__init__.py,sha256=LsGilhl-hBLEn6Glt8S_l0OJzAA1sKit_rui8h-D-p0,488
+cuqi/__init__.py,sha256=TIdTvq0th4ywHVNGFovmEzneXxkpGWC-LlUdrxbPPLM,509
 cuqi/_messages.py,sha256=fzEBrZT2kbmfecBBPm7spVu7yHdxGARQB4QzXhJbCJ0,415
-cuqi/_version.py,sha256=SOLnTN23-4JLBv2uoi0W2XEn60t_evUNUHfiMB7jrSo,510
+cuqi/_version.py,sha256=KFNuS8oqz-QQlxf-6WYMw9whfBWyqAqz9R2yxmZ4u80,509
 cuqi/config.py,sha256=wcYvz19wkeKW2EKCGIKJiTpWt5kdaxyt4imyRkvtTRA,526
 cuqi/diagnostics.py,sha256=5OrbJeqpynqRXOe5MtOKKhe7EAVdOEpHIqHnlMW9G_c,3029
 cuqi/array/__init__.py,sha256=-EeiaiWGNsE3twRS4dD814BIlfxEsNkTCZUc5gjOXb0,30
@@ -13,7 +13,7 @@ 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=BG7gtP0cbFYLVgjYQGkNAhM95PR5ocBVLKRlOVX2PyM,7253
+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
@@ -24,7 +24,7 @@ cuqi/distribution/_gamma.py,sha256=VcvBJS51N-MxuX42r9L2j2QYRlzhdgAtQ6Wa5IFO_YE,3
 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=gBWDb9Aj27m74mSsm9Jj_0mSu0pcEk9Cwdxrzybiwx8,16710
+cuqi/distribution/_joint_distribution.py,sha256=ALOnQsIrzE8Rx_FYOs4f276u4QZQeN_e0CLC7CJpb-E,20396
 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
@@ -34,27 +34,14 @@ cuqi/distribution/_posterior.py,sha256=6LxXAIBzFxyEqx5bUfgqTXVKgXxqNhRItec6FcRVL
 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=9DidfQuoFPr8DnhYzI78N2J0fT4pp-jNle0Rou1fcrM,174
-cuqi/experimental/_recommender.py,sha256=fSCJnlRrUZh-x8-mbVM5WhuPuh7Wmh-4bfvX5PyK_iE,7967
+cuqi/experimental/__init__.py,sha256=HCI1aG9xn4XPnBfGbCRrFaq3JfmVyBH09IuvdDancsY,154
+cuqi/experimental/_recommender.py,sha256=ulW69nDGwkB8X93OMgMVLcVz2L0T3SZqHKG7jZ9wNm8,7907
 cuqi/experimental/algebra/__init__.py,sha256=btRAWG58ZfdtK0afXKOg60AX7d76KMBjlZa4AWBCCgU,81
 cuqi/experimental/algebra/_ast.py,sha256=PdPz19cJMjvnMx4KEzhn4gvxIZX_UViE33Mbttj_5Xw,9873
 cuqi/experimental/algebra/_orderedset.py,sha256=fKysh4pmI4xF7Y5Z6O86ABzg20o4uBs-v8jmLBMrdpo,2849
 cuqi/experimental/algebra/_randomvariable.py,sha256=isbFtIWsWXF-yF5Vb56nLy4MCkQM6akjd-dQau4wfbE,19725
 cuqi/experimental/geometry/__init__.py,sha256=kgoKegfz3Jhr7fpORB_l55z9zLZRtloTLyXFDh1oF2o,47
 cuqi/experimental/geometry/_productgeometry.py,sha256=IlBmmKsWE-aRZHp6no9gUXGRfkHlgM0CdPBx1hax9HI,7199
-cuqi/experimental/mcmc/__init__.py,sha256=hTAssTgtgLhdVZLFX7hpLJYtWmXrmfXb4bWee6ELqwE,4443
-cuqi/experimental/mcmc/_conjugate.py,sha256=vqucxC--pihBCUcupdcIo4ymDPPjmMKGb7OL1THjaKE,22059
-cuqi/experimental/mcmc/_conjugate_approx.py,sha256=jmxe2FEbO9fwpc8opyjJ2px0oed3dGyj0qDwyHo4aOk,3545
-cuqi/experimental/mcmc/_cwmh.py,sha256=cAvtc3tex53ZUKPMGwj2RIkHAZurpqphko8nk8_DmJs,7340
-cuqi/experimental/mcmc/_direct.py,sha256=9pQS_2Qk2-ybt6m8WTfPoKetcxQ00WaTRN85-Z0FrBY,777
-cuqi/experimental/mcmc/_gibbs.py,sha256=k4lVFDha8YNYQ6EXZ6B1kb_3gnJLmsV1Sh_53TaaVME,14021
-cuqi/experimental/mcmc/_hmc.py,sha256=ifDdvs1DPsgQywRyDZx_a4AfzrAM9QaAQk1y0l7Hj6g,19482
-cuqi/experimental/mcmc/_langevin_algorithm.py,sha256=1UunuocpzG1h6GiYefEHFOMykEMlYady6Fmuu9CHxHQ,15059
-cuqi/experimental/mcmc/_laplace_approximation.py,sha256=I5ZLtU0lA34YflRbqxKi5UgJBhhHzxqUyVW5JE5-l2w,5916
-cuqi/experimental/mcmc/_mh.py,sha256=MXo0ahXP4KGFkaY4HtvcBE-TMQzsMlTmLKzSvpz7drU,2941
-cuqi/experimental/mcmc/_pcn.py,sha256=wqJBZLuRFSwxihaI53tumAg6AWVuceLMOmXssTetd1A,3374
-cuqi/experimental/mcmc/_rto.py,sha256=O_bBeQbaYy5im5LKAhwin3uRCJpyFPcKVDH8GxriXEY,17196
-cuqi/experimental/mcmc/_sampler.py,sha256=7_a9i6A7AX3NNz7qK1jTsEYt6bFCUR5WK464KfH_Kvc,21034
 cuqi/geometry/__init__.py,sha256=Tz1WGzZBY-QGH3c0GiyKm9XHN8MGGcnU6TUHLZkzB3o,842
 cuqi/geometry/_geometry.py,sha256=W-oQTZPelVS7fN9qZj6bNBuh-yY0eqOHJ39UwB-WmQY,47562
 cuqi/implicitprior/__init__.py,sha256=6Fl4Lmld8ikg9sW9tReKRGTCJC6_WCTExHaYuIv34nM,323
@@ -62,6 +49,19 @@ cuqi/implicitprior/_regularizedGMRF.py,sha256=BUeT4rwJzary9K56fkxCNGCeKZd-2VSgOT
 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
@@ -71,19 +71,20 @@ cuqi/operator/_operator.py,sha256=yNwPTh7jR07AiKMbMQQ5_54EgirlKFsbq9JN1EODaQI,88
 cuqi/pde/__init__.py,sha256=NyS_ZYruCvy-Yg24qKlwm3ZIX058kLNQX9bqs-xg4ZM,99
 cuqi/pde/_pde.py,sha256=FxCmMPcbRj9ulJbg3fPzQITfHKeW9I8r1S2v9Odz0WU,15806
 cuqi/problem/__init__.py,sha256=JxJty4JqHTOqSG6NeTGiXRQ7OLxiRK9jvVq3lXLeIRw,38
-cuqi/problem/_problem.py,sha256=p1UO04GKv5BmdcPR5-xcP-idBsqShBxKJ3WC5qNSMDs,38588
-cuqi/sampler/__init__.py,sha256=D-dYa0gFgIwQukP8_VKhPGmlGKXbvVo7YqaET4SdAeQ,382
-cuqi/sampler/_conjugate.py,sha256=x5OsFk1zDm2tvoFsSxbCKwjSqBHUGbcUvcTwDOvL-tw,2841
-cuqi/sampler/_conjugate_approx.py,sha256=xX-X71EgxGnZooOY6CIBhuJTs3dhcKfoLnoFxX3CO2g,1938
-cuqi/sampler/_cwmh.py,sha256=VlAVT1SXQU0yD5ZeR-_ckWvX-ifJrMweFFdFbxdfB_k,7775
-cuqi/sampler/_gibbs.py,sha256=N7qcePwMkRtxINN5JF0FaMIdDCXZGqsfKjfha_KHCck,8627
-cuqi/sampler/_hmc.py,sha256=EUTefZir-wapoZ7OZFb5M5vayL8z6XksZRMY1BpbuXc,15027
-cuqi/sampler/_langevin_algorithm.py,sha256=o5EyvaR6QGAD7LKwXVRC3WwAP5IYJf5GoMVWl9DrfOA,7861
-cuqi/sampler/_laplace_approximation.py,sha256=M0SnpICcf8No1zsPKopGEncVgLqBUI7VUDf9-YIkk_g,6565
-cuqi/sampler/_mh.py,sha256=V5tIdn-KdfWo4J_Nbf-AH6XwKWblWUyc4BeuSikUHsE,7062
-cuqi/sampler/_pcn.py,sha256=F0h9-nUFtkqn-o-1s8BCsmr8V7u6R7ycoCOeeV1uhj0,8601
-cuqi/sampler/_rto.py,sha256=KIs0cDEoYK5I35RwO9fr5eKWeINLsmTLSVBnLdZmzzM,11921
-cuqi/sampler/_sampler.py,sha256=TkZ_WAS-5Q43oICa-Elc2gftsRTBd7PEDUMDZ9tTGmU,5712
+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=H8ZYoNGyQun2u9dU86HDfr5Z1zZO9AnwkeATgS3Jer8,13971
+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=vilU7YjU2WrK5b4bh4VAv8a8TTgj1f9Osivcf3kUlFQ,3364
+cuqi/sampler/_rto.py,sha256=AQFi8Kqa3uQZsZxdpPb2B9Is_lyfz1v8l9JAY3e4J2w,17186
+cuqi/sampler/_sampler.py,sha256=7_a9i6A7AX3NNz7qK1jTsEYt6bFCUR5WK464KfH_Kvc,21034
 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
@@ -93,8 +94,8 @@ cuqi/testproblem/_testproblem.py,sha256=EJWG_zXUtmo6GlHBZFqHlRpDC_48tE0XZEu0_C66
 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.3.0.post0.dev401.dist-info/licenses/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
-cuqipy-1.3.0.post0.dev401.dist-info/METADATA,sha256=tSP-CHhdOy1toeu4080aq-6thVow3YK_LpNpT5q95T0,18624
-cuqipy-1.3.0.post0.dev401.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cuqipy-1.3.0.post0.dev401.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
-cuqipy-1.3.0.post0.dev401.dist-info/RECORD,,
+cuqipy-1.4.0.post0.dev41.dist-info/licenses/LICENSE,sha256=kJWRPrtRoQoZGXyyvu50Uc91X6_0XRaVfT0YZssicys,10799
+cuqipy-1.4.0.post0.dev41.dist-info/METADATA,sha256=04IajL7bTvxKr5iSFSJJdvMlBiepT6kptUDG6luIFmI,18623
+cuqipy-1.4.0.post0.dev41.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cuqipy-1.4.0.post0.dev41.dist-info/top_level.txt,sha256=AgmgMc6TKfPPqbjV0kvAoCBN334i_Lwwojc7HE3ZwD0,5
+cuqipy-1.4.0.post0.dev41.dist-info/RECORD,,

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)