qpytorch 0.1__py3-none-any.whl

qpytorch/variational/variational_strategy.py

@@ -0,0 +1,280 @@
+#!/usr/bin/env python3
+
+import warnings
+from typing import Any, Dict, Iterable, Optional, Tuple, Union
+
+import torch
+from linear_operator import to_dense
+from linear_operator.operators import (
+    CholLinearOperator,
+    DiagLinearOperator,
+    LinearOperator,
+    MatmulLinearOperator,
+    RootLinearOperator,
+    SumLinearOperator,
+    TriangularLinearOperator,
+)
+from linear_operator.utils.cholesky import psd_safe_cholesky
+from linear_operator.utils.errors import NotPSDError
+from torch import Tensor
+
+from ._variational_strategy import _VariationalStrategy
+from .cholesky_variational_distribution import CholeskyVariationalDistribution
+
+from ..distributions import MultivariateNormal, MultivariateQExponential
+from ..models import ApproximateGP, ApproximateQEP
+from gpytorch.settings import _linalg_dtype_cholesky, trace_mode
+from gpytorch.utils.errors import CachingError
+from gpytorch.utils.memoize import cached, clear_cache_hook, pop_from_cache_ignore_args
+from ..utils.warnings import OldVersionWarning
+from . import _VariationalDistribution
+
+
+def _ensure_updated_strategy_flag_set(
+    state_dict: Dict[str, Tensor],
+    prefix: str,
+    local_metadata: Dict[str, Any],
+    strict: bool,
+    missing_keys: Iterable[str],
+    unexpected_keys: Iterable[str],
+    error_msgs: Iterable[str],
+):
+    device = state_dict[list(state_dict.keys())[0]].device
+    if prefix + "updated_strategy" not in state_dict:
+        state_dict[prefix + "updated_strategy"] = torch.tensor(False, device=device)
+        warnings.warn(
+            "You have loaded a variational GP (QEP) model (using `VariationalStrategy`) from a previous version of "
+            "GPyTorch. We have updated the parameters of your model to work with the new version of "
+            "`VariationalStrategy` that uses whitened parameters.\nYour model will work as expected, but we "
+            "recommend that you re-save your model.",
+            OldVersionWarning,
+        )
+
+
+class VariationalStrategy(_VariationalStrategy):
+    r"""
+    The standard variational strategy, as defined by `Hensman et al. (2015)`_.
+    This strategy takes a set of :math:`m \ll n` inducing points :math:`\mathbf Z`
+    and applies an approximate distribution :math:`q( \mathbf u)` over their function values.
+    (Here, we use the common notation :math:`\mathbf u = f(\mathbf Z)`.
+    The approximate function distribution for any abitrary input :math:`\mathbf X` is given by:
+
+    .. math::
+
+        q( f(\mathbf X) ) = \int p( f(\mathbf X) \mid \mathbf u) q(\mathbf u) \: d\mathbf u
+
+    This variational strategy uses "whitening" to accelerate the optimization of the variational
+    parameters. See `Matthews (2017)`_ for more info.
+
+    :param model: Model this strategy is applied to.
+        Typically passed in when the VariationalStrategy is created in the
+        __init__ method of the user defined model.
+        It should contain power if Q-Exponential distribution is involved in.
+    :param inducing_points: Tensor containing a set of inducing
+        points to use for variational inference.
+    :param variational_distribution: A
+        VariationalDistribution object that represents the form of the variational distribution :math:`q(\mathbf u)`
+    :param learn_inducing_locations: (Default True): Whether or not
+        the inducing point locations :math:`\mathbf Z` should be learned (i.e. are they
+        parameters of the model).
+    :param jitter_val: Amount of diagonal jitter to add for Cholesky factorization numerical stability
+
+    .. _Hensman et al. (2015):
+        http://proceedings.mlr.press/v38/hensman15.pdf
+    .. _Matthews (2017):
+        https://www.repository.cam.ac.uk/handle/1810/278022
+    """
+
+    def __init__(
+        self,
+        model: Union[ApproximateGP, ApproximateQEP],
+        inducing_points: Tensor,
+        variational_distribution: _VariationalDistribution,
+        learn_inducing_locations: bool = True,
+        jitter_val: Optional[float] = None,
+    ):
+        super().__init__(
+            model, inducing_points, variational_distribution, learn_inducing_locations, jitter_val=jitter_val
+        )
+        self.register_buffer("updated_strategy", torch.tensor(True))
+        self._register_load_state_dict_pre_hook(_ensure_updated_strategy_flag_set)
+        self.has_fantasy_strategy = True
+
+    @cached(name="cholesky_factor", ignore_args=True)
+    def _cholesky_factor(self, induc_induc_covar: LinearOperator) -> TriangularLinearOperator:
+        L = psd_safe_cholesky(to_dense(induc_induc_covar).type(_linalg_dtype_cholesky.value()))
+        return TriangularLinearOperator(L)
+
+    @property
+    @cached(name="prior_distribution_memo")
+    def prior_distribution(self) -> Union[MultivariateNormal, MultivariateQExponential]:
+        zeros = torch.zeros(
+            self._variational_distribution.shape(),
+            dtype=self._variational_distribution.dtype,
+            device=self._variational_distribution.device,
+        )
+        ones = torch.ones_like(zeros)
+        if hasattr(self.model, 'power'):
+            res = MultivariateQExponential(zeros, DiagLinearOperator(ones), power=self.model.power)
+        else:
+            res = MultivariateNormal(zeros, DiagLinearOperator(ones))
+        return res
+
+    @property
+    @cached(name="pseudo_points_memo")
+    def pseudo_points(self) -> Tuple[Tensor, Tensor]:
+        # TODO: have var_mean, var_cov come from a method of _variational_distribution
+        # while having Kmm_root be a root decomposition to enable CIQVariationalDistribution support.
+
+        # retrieve the variational mean, m and covariance matrix, S.
+        if not isinstance(self._variational_distribution, CholeskyVariationalDistribution):
+            raise NotImplementedError(
+                "Only CholeskyVariationalDistribution has pseudo-point support currently, ",
+                "but your _variational_distribution is a ",
+                self._variational_distribution.__name__,
+            )
+
+        var_cov_root = TriangularLinearOperator(self._variational_distribution.chol_variational_covar)
+        var_cov = CholLinearOperator(var_cov_root)
+        var_mean = self.variational_distribution.mean
+        if var_mean.shape[-1] != 1:
+            var_mean = var_mean.unsqueeze(-1)
+
+        # compute R = I - S
+        cov_diff = var_cov.add_jitter(-1.0)
+        cov_diff = -1.0 * cov_diff
+
+        # K^{1/2}
+        Kmm = self.model.covar_module(self.inducing_points)
+        Kmm_root = Kmm.cholesky()
+
+        # D_a = (S^{-1} - K^{-1})^{-1} = S + S R^{-1} S
+        # note that in the whitened case R = I - S, unwhitened R = K - S
+        # we compute (R R^{T})^{-1} R^T S for stability reasons as R is probably not PSD.
+        eval_var_cov = var_cov.to_dense()
+        eval_rhs = cov_diff.transpose(-1, -2).matmul(eval_var_cov)
+        inner_term = cov_diff.matmul(cov_diff.transpose(-1, -2))
+        # TODO: flag the jitter here
+        inner_solve = inner_term.add_jitter(self.jitter_val).solve(eval_rhs, eval_var_cov.transpose(-1, -2))
+        inducing_covar = var_cov + inner_solve
+
+        inducing_covar = Kmm_root.matmul(inducing_covar).matmul(Kmm_root.transpose(-1, -2))
+
+        # mean term: D_a S^{-1} m
+        # unwhitened: (S - S R^{-1} S) S^{-1} m = (I - S R^{-1}) m
+        rhs = cov_diff.transpose(-1, -2).matmul(var_mean)
+        # TODO: this jitter too
+        inner_rhs_mean_solve = inner_term.add_jitter(self.jitter_val).solve(rhs)
+        pseudo_target_mean = Kmm_root.matmul(inner_rhs_mean_solve)
+
+        # ensure inducing covar is psd
+        # TODO: make this be an explicit root decomposition
+        try:
+            pseudo_target_covar = CholLinearOperator(inducing_covar.add_jitter(self.jitter_val).cholesky()).to_dense()
+        except NotPSDError:
+            from linear_operator.operators import DiagLinearOperator
+
+            evals, evecs = torch.linalg.eigh(inducing_covar)
+            pseudo_target_covar = (
+                evecs.matmul(DiagLinearOperator(evals + self.jitter_val)).matmul(evecs.transpose(-1, -2)).to_dense()
+            )
+
+        return pseudo_target_covar, pseudo_target_mean
+
+    def forward(
+        self,
+        x: Tensor,
+        inducing_points: Tensor,
+        inducing_values: Tensor,
+        variational_inducing_covar: Optional[LinearOperator] = None,
+        **kwargs,
+    ) -> Union[MultivariateNormal, MultivariateQExponential]:
+        # Compute full prior distribution
+        full_inputs = torch.cat([inducing_points, x], dim=-2)
+        full_output = self.model.forward(full_inputs, **kwargs)
+        full_covar = full_output.lazy_covariance_matrix
+
+        # Covariance terms
+        num_induc = inducing_points.size(-2)
+        test_mean = full_output.mean[..., num_induc:]
+        induc_induc_covar = full_covar[..., :num_induc, :num_induc].add_jitter(self.jitter_val)
+        induc_data_covar = full_covar[..., :num_induc, num_induc:].to_dense()
+        data_data_covar = full_covar[..., num_induc:, num_induc:]
+
+        # Compute interpolation terms
+        # K_ZZ^{-1/2} K_ZX
+        # K_ZZ^{-1/2} \mu_Z
+        L = self._cholesky_factor(induc_induc_covar)
+        if L.shape != induc_induc_covar.shape:
+            # Aggressive caching can cause nasty shape incompatibilies when evaluating with different batch shapes
+            # TODO: Use a hook fo this
+            try:
+                pop_from_cache_ignore_args(self, "cholesky_factor")
+            except CachingError:
+                pass
+            L = self._cholesky_factor(induc_induc_covar)
+        interp_term = L.solve(induc_data_covar.type(_linalg_dtype_cholesky.value())).to(full_inputs.dtype)
+
+        # Compute the mean of q(f)
+        # k_XZ K_ZZ^{-1/2} (m - K_ZZ^{-1/2} \mu_Z) + \mu_X
+        predictive_mean = (interp_term.transpose(-1, -2) @ inducing_values.unsqueeze(-1)).squeeze(-1) + test_mean
+
+        # Compute the covariance of q(f)
+        # K_XX + k_XZ K_ZZ^{-1/2} (S - I) K_ZZ^{-1/2} k_ZX
+        middle_term = self.prior_distribution.lazy_covariance_matrix.mul(-1)
+        if variational_inducing_covar is not None:
+            middle_term = SumLinearOperator(variational_inducing_covar, middle_term)
+
+        if trace_mode.on():
+            predictive_covar = (
+                data_data_covar.add_jitter(self.jitter_val).to_dense()
+                + interp_term.transpose(-1, -2) @ middle_term.to_dense() @ interp_term
+            )
+        else:
+            predictive_covar = SumLinearOperator(
+                data_data_covar.add_jitter(self.jitter_val),
+                MatmulLinearOperator(interp_term.transpose(-1, -2), middle_term @ interp_term),
+            )
+
+        # Return the distribution
+        if hasattr(self.model, 'power'):
+            return MultivariateQExponential(predictive_mean, predictive_covar, power=self.model.power)
+        else:
+            return MultivariateNormal(predictive_mean, predictive_covar)
+
+    def __call__(self, x: Tensor, prior: bool = False, **kwargs) -> Union[MultivariateNormal, MultivariateQExponential]:
+        if not self.updated_strategy.item() and not prior:
+            with torch.no_grad():
+                # Get unwhitened p(u)
+                prior_function_dist = self(self.inducing_points, prior=True)
+                prior_mean = prior_function_dist.loc
+                L = self._cholesky_factor(prior_function_dist.lazy_covariance_matrix.add_jitter(self.jitter_val))
+
+                # Temporarily turn off noise that's added to the mean
+                orig_mean_init_std = self._variational_distribution.mean_init_std
+                self._variational_distribution.mean_init_std = 0.0
+
+                # Change the variational parameters to be whitened
+                variational_dist = self.variational_distribution
+                if isinstance(variational_dist, (MultivariateNormal, MultivariateQExponential)):
+                    mean_diff = (variational_dist.loc - prior_mean).unsqueeze(-1).type(_linalg_dtype_cholesky.value())
+                    whitened_mean = L.solve(mean_diff).squeeze(-1).to(variational_dist.loc.dtype)
+                    covar_root = variational_dist.lazy_covariance_matrix.root_decomposition().root.to_dense()
+                    covar_root = covar_root.type(_linalg_dtype_cholesky.value())
+                    whitened_covar = RootLinearOperator(L.solve(covar_root).to(variational_dist.loc.dtype))
+                    whitened_variational_distribution = variational_dist.__class__(whitened_mean, whitened_covar)
+                    if isinstance(variational_dist, MultivariateQExponential): whitened_variational_distribution.power = variational_dist.power
+                    self._variational_distribution.initialize_variational_distribution(
+                        whitened_variational_distribution
+                    )
+
+                # Reset the random noise parameter of the model
+                self._variational_distribution.mean_init_std = orig_mean_init_std
+
+                # Reset the cache
+                clear_cache_hook(self)
+
+                # Mark that we have updated the variational strategy
+                self.updated_strategy.fill_(True)
+
+        return super().__call__(x, prior=prior, **kwargs)

qpytorch/version.py

@@ -0,0 +1,4 @@
+# file generated by setuptools_scm
+# don't change, don't track in version control
+__version__ = version = '0.1'
+__version_tuple__ = version_tuple = (0, 1)

qpytorch-0.1.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shiwei Lan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qpytorch-0.1.dist-info/METADATA

@@ -0,0 +1,177 @@
+Metadata-Version: 2.1
+Name: qpytorch
+Version: 0.1
+Summary: An implementation of Q-Exponential Processes in Pytorch based on GPyTorch
+Home-page: https://lanzithinking.github.io/qepytorch/
+Author: Shiwei Lan
+Author-email: lanzithinking@gmail.com
+License: MIT
+Project-URL: Documentation, https://qepytorch.readthedocs.io
+Project-URL: Source, https://github.com/lanzithinking/qepytorch/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jaxtyping
+Requires-Dist: mpmath<=1.3,>=0.19
+Requires-Dist: scikit-learn
+Requires-Dist: scipy>=1.6.0
+Requires-Dist: linear-operator>=0.6
+Requires-Dist: gpytorch>=1.13
+Provides-Extra: dev
+Requires-Dist: pre-commit; extra == "dev"
+Requires-Dist: setuptools-scm; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Requires-Dist: ufmt; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: ipykernel<=6.17.1; extra == "docs"
+Requires-Dist: ipython<=8.6.0; extra == "docs"
+Requires-Dist: m2r2<=0.3.3.post2; extra == "docs"
+Requires-Dist: nbclient<=0.7.3; extra == "docs"
+Requires-Dist: nbformat<=5.8.0; extra == "docs"
+Requires-Dist: nbsphinx<=0.9.1; extra == "docs"
+Requires-Dist: lxml-html-clean; extra == "docs"
+Requires-Dist: pandoc<=3.0.0; extra == "docs"
+Requires-Dist: platformdirs<=3.2.0; extra == "docs"
+Requires-Dist: setuptools-scm<=7.1.0; extra == "docs"
+Requires-Dist: sphinx<=6.2.1; extra == "docs"
+Requires-Dist: sphinx-autodoc-typehints<=1.23.0; extra == "docs"
+Requires-Dist: sphinx-rtd-theme<0.5; extra == "docs"
+Provides-Extra: examples
+Requires-Dist: ipython; extra == "examples"
+Requires-Dist: jupyter; extra == "examples"
+Requires-Dist: matplotlib; extra == "examples"
+Requires-Dist: scipy; extra == "examples"
+Requires-Dist: torchvision; extra == "examples"
+Requires-Dist: tqdm; extra == "examples"
+Provides-Extra: keops
+Requires-Dist: pykeops>=1.1.1; extra == "keops"
+Provides-Extra: pyro
+Requires-Dist: pyro-ppl>=1.8; extra == "pyro"
+Provides-Extra: test
+Requires-Dist: flake8==4.0.1; extra == "test"
+Requires-Dist: flake8-print==4.0.0; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: nbval; extra == "test"
+
+# Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch
+
+---
+[![Test Suite](https://github.com/lanzithinking/qepytorch/actions/workflows/run_test_suite.yml/badge.svg)](https://github.com/lanzithinking/qepytorch/actions/workflows/run_test_suite.yml)
+[![Documentation Status](https://readthedocs.org/projects/qepytorch/badge/?version=latest)](https://qepytorch.readthedocs.io/en/latest/?badge=latest)
+[![License](https://img.shields.io/badge/license-MIT-green.svg)](LICENSE)
+
+[![Python Version](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![Conda](https://img.shields.io/conda/v/conda-forge/qpytorch.svg)](https://anaconda.org/conda-forge/qpytorch)
+[![PyPI](https://img.shields.io/pypi/v/qpytorch.svg)](https://pypi.org/project/qpytorch)
+
+Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is a Q-exponential process library implemented using PyTorch built on [GPyTorch](https://gpytorch.ai). Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is designed for creating scalable, flexible, and modular Q-exponential process models with ease.
+
+Internally, Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch differs from many existing approaches to QEP inference by performing most inference operations using numerical linear algebra techniques like preconditioned conjugate gradients.
+Implementing a scalable QEP method is as simple as providing a matrix multiplication routine with the kernel matrix and its derivative via our [LinearOperator](https://github.com/cornellius-gp/linear_operator) interface,
+or by composing many of our already existing `LinearOperators`.
+This allows not only for easy implementation of popular scalable QEP techniques,
+but often also for significantly improved utilization of GPU computing compared to solvers based on the Cholesky decomposition.
+
+Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch provides (1) significant GPU acceleration (through MVM based inference);
+(2) state-of-the-art implementations of the latest algorithmic advances for scalability and flexibility ([SKI/KISS-GP](http://proceedings.mlr.press/v37/wilson15.pdf), [stochastic Lanczos expansions](https://arxiv.org/abs/1711.03481), [LOVE](https://arxiv.org/pdf/1803.06058.pdf), [SKIP](https://arxiv.org/pdf/1802.08903.pdf), [stochastic variational](https://arxiv.org/pdf/1611.00336.pdf) [deep kernel learning](http://proceedings.mlr.press/v51/wilson16.pdf), ...);
+(3) easy integration with deep learning frameworks.
+
+
+## Examples, Tutorials, and Documentation
+
+See our [**documentation, examples, tutorials**](https://qepytorch.readthedocs.io/en/stable/) on how to construct all sorts of models in Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch.
+
+## Installation
+
+**Requirements**:
+- Python >= 3.10
+- PyTorch >= 2.2
+- GPyTorch >= 1.13
+
+Install Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch using pip or conda:
+
+```bash
+pip install qpytorch
+conda install qpytorch -c qpytorch
+```
+
+(To use packages globally but install Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch as a user-only package, use `pip install --user` above.)
+
+#### Latest (Unstable) Version
+
+To upgrade to the latest (unstable) version, run
+
+```bash
+pip install --upgrade git+https://github.com/cornellius-gp/linear_operator.git
+pip install --upgrade git+https://github.com/cornellius-gp/gpytorch.git
+pip install --upgrade git+https://github.com/lanzithinking/qepytorch.git
+```
+
+#### Development version
+
+If you are contributing a pull request, it is best to perform a manual installation:
+
+```sh
+git clone https://github.com/lanzithinking/qepytorch.git qpytorch
+cd qpytorch
+pip install -e .[dev,docs,examples,keops,pyro,test]  # keops and pyro are optional
+```
+
+<!--
+#### ArchLinux Package
+**Note**: Experimental AUR package. For most users, we recommend installation by conda or pip.
+-->
+<!--
+Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is also available on the [ArchLinux User Repository](https://wiki.archlinux.org/index.php/Arch_User_Repository) (AUR).
+You can install it with an [AUR helper](https://wiki.archlinux.org/index.php/AUR_helpers), like [`yay`](https://aur.archlinux.org/packages/yay/), as follows:
+-->
+<!--
+```bash
+yay -S python-qpytorch
+```
+To discuss any issues related to this AUR package refer to the comments section of
+[`python-qpytorch`](https://aur.archlinux.org/packages/python-qpytorch/).
+-->
+
+## Citing Us
+
+If you use Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch, please cite the following papers:
+> [Li, Shuyi, Michael O'Connor, and Shiwei Lan. "Bayesian Learning via Q-Exponential Process." In Advances in Neural Information Processing Systems (2023).](https://papers.nips.cc/paper_files/paper/2023/hash/e6bfdd58f1326ff821a1b92743963bdf-Abstract-Conference.html)
+```
+@inproceedings{li2023QEP,
+  title={Bayesian Learning via Q-Exponential Process},
+  author={Li, Shuyi, Michael O'Connor, and Shiwei Lan},
+  booktitle={Advances in Neural Information Processing Systems},
+  year={2023}
+}
+```
+
+## Contributing
+
+See the contributing guidelines [CONTRIBUTING.md](https://github.com/lanzithinking/qepytorch/blob/main/CONTRIBUTING.md)
+for information on submitting issues and pull requests.
+
+
+## The Team
+
+Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is primarily maintained by:
+- [Shiwei Lan](https://math.la.asu.edu/~slan) (Arizona State University)
+
+We would like to thank our other contributors including (but not limited to)
+Shuyi Li,
+Guangting Yu,
+Zhi Chang,
+Chukwudi Paul Obite,
+Keyan Wu,
+and many more!
+
+
+## Acknowledgements
+Development of Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is supported by.
+
+
+## License
+
+Q<sup style="font-size: 0.5em;">&#9428;</sup>PyTorch is [MIT licensed](https://github.com/lanzithinking/qepytorch/blob/main/LICENSE).

qpytorch-0.1.dist-info/RECORD

@@ -0,0 +1,102 @@
+qpytorch/__init__.py,sha256=0sD7DfLvEXx3PvqrTyl5bOYprus1Wjzxs1hOzTbQx6s,12392
+qpytorch/module.py,sha256=xjw6X-v3_iVt4cOUEQdQp-cbTKkLCqwaeJoUardRQSQ,1259
+qpytorch/version.py,sha256=Ljuux5HvS-yDzAhpzt_WxHJ6Ct4dLQiCUJg2yT5NuzE,155
+qpytorch/constraints/__init__.py,sha256=JS4bzSGrgAiDtOM_Y4rerzkoMAUt671E2U1SVakhfX4,138
+qpytorch/distributions/__init__.py,sha256=OSVX5Lfb72NKVFWVku0t-D2RyZuVcJAIICndOX9f5EA,973
+qpytorch/distributions/delta.py,sha256=AC-N5fhBQad872jl8q9PMLq46E5qwcQOXkRf1PSW-Cg,3507
+qpytorch/distributions/multitask_multivariate_qexponential.py,sha256=mttRjFp_hx-Sjxi-061sRuGeFmpA_hQFLx6cYgnUBqc,21584
+qpytorch/distributions/multivariate_qexponential.py,sha256=BUBPyEqoXR7E1VY3uW-DbWSr-h-94WXGxLzkKXluR3Q,28885
+qpytorch/distributions/power.py,sha256=a1_MMLJk-P1UcLNRtoquoBcbl1Rpwq_6UvlJR-8RPY0,3777
+qpytorch/distributions/qexponential.py,sha256=9O_uquDARLSamDnEsbaJJ3GZbtY3Mv2PqEiwVMwLU2M,5969
+qpytorch/functions/__init__.py,sha256=rLKoyZQNW0DttCQGAxu5SgKOeZZXsp1wJnABi5WL5kY,1655
+qpytorch/kernels/__init__.py,sha256=2TlJ4Vq8mGg4KE19K8OfQwZf3A5hRiUm53KdX7ZUkCc,3229
+qpytorch/kernels/grid_interpolation_kernel.py,sha256=l0t0pJ0EWHaCaP_rkJo1BL63gEoKAIX3kYc8rQFWjN8,9108
+qpytorch/kernels/inducing_point_kernel.py,sha256=yRp2_w0q8HkOCb4sbuVEebdlGnRhR9cQtYir5cr-6lo,5451
+qpytorch/kernels/kernel.py,sha256=UBBTelSm2nFS1JU2kfaXMzlWCKEdbrhMh6aKqh3_1_w,29415
+qpytorch/kernels/matern32_kernel_grad.py,sha256=W5P5XSWTdeHdw9zrbpInOyIUhCFW_Z86CJ9D1biK6MY,7050
+qpytorch/kernels/matern52_kernel_grad.py,sha256=mBkwuGBiVFudJ9zNfcoMn7_j9mbBgm37w853njZK48o,8638
+qpytorch/kernels/matern52_kernel_gradgrad.py,sha256=1jc012aYCWAT2qNBhW60fM0IKberW5qLkvptAhXq9ys,12846
+qpytorch/kernels/polynomial_kernel_grad.py,sha256=vM8y00lEGz4Z-ceZ3wJ33pL5rD16gehUpYjJ-PVnPbE,3708
+qpytorch/kernels/qexponential_symmetrized_kl_kernel.py,sha256=pMZpjU3phGEBQ_O7K9sRFQgwfX5rMtaowsVteJ9hdr4,2932
+qpytorch/kernels/rbf_kernel_grad.py,sha256=bVUfbkn1k01X4cix2XTTWJZXtezIX4JBtvKpHkB_C5s,5917
+qpytorch/kernels/rbf_kernel_gradgrad.py,sha256=0v17TMsxURKPigOvYLGy7OwHeOleTBXhk5UaE2WUpv8,9392
+qpytorch/kernels/rff_kernel.py,sha256=kmP4U2mJX_OtjhAdlevxQfbBpIfOCNKSPAGcrQJiTSo,5967
+qpytorch/lazy/__init__.py,sha256=9O54rlcJMXrzGs5BWcLCAAuNluQVS2FxiTgKkBRQwCQ,189
+qpytorch/likelihoods/__init__.py,sha256=knFtCZOf5hLgX3XWEBnkf-RfY0NFJ9gs7aEiG0ex3es,2291
+qpytorch/likelihoods/bernoulli_likelihood.py,sha256=TuARyzTBS9CXJ_gTPHbshozH1rUFFSaqD0WD9Vf8J6c,2938
+qpytorch/likelihoods/beta_likelihood.py,sha256=uPixvFYX_ILVm44rl1uNSPoaRf5v83QMN8ta35YY_rA,2688
+qpytorch/likelihoods/gaussian_likelihood.py,sha256=OI4vi-Bo_ta08jJ_fsnJuc2oNP4YsVFYs8RfafsCbaI,19525
+qpytorch/likelihoods/laplace_likelihood.py,sha256=WAWnM-JBn-jKoLS-_294CWe0o4y70E5IxWhP-C2vXCg,2002
+qpytorch/likelihoods/likelihood.py,sha256=4b5CvQrH0JWOXPQnP-qVw9iZnVj-G0WE4bjUVkVOGiI,22659
+qpytorch/likelihoods/likelihood_list.py,sha256=eHmI0Vub8A88OvRCOU2yD__AVFcMWXOuS5HvqT164eE,2119
+qpytorch/likelihoods/multitask_gaussian_likelihood.py,sha256=rkEAW1eRn3IjdL7rFS8gsupzJG7MGXM1LhkaNZ7D-Ho,24779
+qpytorch/likelihoods/multitask_qexponential_likelihood.py,sha256=0u5HNN-oM-nJ-B6k6j5snGNJ-3SQyHSxuXFJC_g8tZg,25238
+qpytorch/likelihoods/noise_models.py,sha256=0ebjtb7A3P1WbXMsXe2XMcSNxyKMpSh85_3DNjMeYdQ,8166
+qpytorch/likelihoods/qexponential_likelihood.py,sha256=mrFWQ84s3fWXziyjtIkS52ndCcc0Xe6q_MW7irXCHrQ,21357
+qpytorch/likelihoods/softmax_likelihood.py,sha256=_Q6K3unAgoOSWkZSGeK84-RqoaIz4k6ihf2DGAWqO1k,4558
+qpytorch/likelihoods/student_t_likelihood.py,sha256=Iv7IGu0K_xkjgC0N6SGaII-Vov8QtQzjtQPmD5WN6vE,3364
+qpytorch/means/__init__.py,sha256=7Gj9e8VijlDYJEWXYU2AKWOgkw-SwzM_qgnODNWifhk,729
+qpytorch/metrics/__init__.py,sha256=BLnN_PXczngBRxvsQEZ6Mw_cf345wzSnlUA5m1y-rV8,428
+qpytorch/mlls/__init__.py,sha256=HnB2efNG-hWbECBprxoqoWvvZPnI2fajNEfHbzV-pNI,2066
+qpytorch/mlls/_approximate_mll.py,sha256=RaEaQAhf5Bkca0t6E3ix7ctz84AmgK3PXx500QxrLUM,3592
+qpytorch/mlls/deep_approximate_mll.py,sha256=TZxH3M-whckfZbL3s9XBsMvpGHeHfGNwT0xTv0MO93I,1236
+qpytorch/mlls/deep_predictive_log_likelihood.py,sha256=3sxp9-fSIWt8V_dQG_ayrnvLgN-Ve9A-4c7JEY8j6A0,1377
+qpytorch/mlls/exact_marginal_log_likelihood.py,sha256=dd7yD6wskbbqrNTlSxoR_mEQ8WmJH6ILAWHeZ1omCcg,4799
+qpytorch/mlls/gamma_robust_variational_elbo.py,sha256=6NB6FtkEy5YL6r75kMqMptkROpGWh0QeV540rlNE2vI,4816
+qpytorch/mlls/inducing_point_kernel_added_loss_term.py,sha256=ZQvNip6k95iV-Bdy6RdhsCHWS3KVdB5jXeg5Zi1IcU4,3824
+qpytorch/mlls/kl_qexponential_added_loss_term.py,sha256=9tT2CWck5uzwmHuFjkm1eHuovLBvlQXGbBctu-GuOik,1541
+qpytorch/mlls/leave_one_out_pseudo_likelihood.py,sha256=ZXQ6Rj-zHiD2Mjqm_rk_mcVTgA5otpiMSVNJtFYq1bI,3989
+qpytorch/mlls/marginal_log_likelihood.py,sha256=BjuM9apQ7b79x6jdjliK_h24O8Yy9zMMIwLlveFdJhs,2187
+qpytorch/mlls/predictive_log_likelihood.py,sha256=tGGkzu29Cs91BeDxCRC_s-l3idhbHuus3XTPni0SlL0,4015
+qpytorch/mlls/sum_marginal_log_likelihood.py,sha256=la3teD1VC_Xh4FUCyIGphWkRkdTzuMtgcj2R1NA2fc4,1641
+qpytorch/mlls/variational_elbo.py,sha256=M9H-nKRsQsfpHewmUihePzcGlKe_fPqnLQWoPl2nrqI,4082
+qpytorch/models/__init__.py,sha256=IybxlfX2XGo8bOoQE7BPlv9G-fqP6EnkVZHnS01nbJ8,2103
+qpytorch/models/approximate_qep.py,sha256=UxLcwzP1ykDKuLKFIZxljanQ3Mw7Gk_K67W341nOJd8,5577
+qpytorch/models/exact_prediction_strategies.py,sha256=gzTjc8rjiHTaXk0STKl-HocrOxzyWGfXV9Iq0DwYJUU,43305
+qpytorch/models/exact_qep.py,sha256=qPSxipLTa0KRJUcBpf85XXOVP2QItYQKnbxw4n9zcnc,16910
+qpytorch/models/model_list.py,sha256=oAol6X6S4-Pd6NHt-El9R3dAL09m4fITHWJFw9Y7qnY,3342
+qpytorch/models/qep.py,sha256=RLoLOs7XwLCRT2zDbief8le2vVExTnOWUIqqIhyB0Po,82
+qpytorch/models/deep_qeps/__init__.py,sha256=GblwsDly1YxZMZVMz91aIxDWJdRL4ndr-PMYNldtDKo,694
+qpytorch/models/deep_qeps/deep_qep.py,sha256=IyW4udmQZtrp8TVf79vU5p6pQxfaJiW7GW4dxSPFVyg,6651
+qpytorch/models/deep_qeps/dspp.py,sha256=xOb63PWU5eYlV6Im36meWXl3S9bSSOHZGMdPW5wvc1E,5155
+qpytorch/models/pyro/__init__.py,sha256=48AjdCGvlLHRjHggbSH6zZtMXBnbRjYjWxn5KyEmWHk,1024
+qpytorch/models/pyro/_pyro_mixin.py,sha256=Lj9wdVDEVp1eAhYqNbykT7Cy3j6tobRkn9CNOFAMMy4,2790
+qpytorch/models/pyro/pyro_qep.py,sha256=RSnuPxVzHhQWnfz61Tno_xsKhVp8otJ143mO4evun18,4655
+qpytorch/models/pyro/distributions/__init__.py,sha256=RiVEFSDwU_4auqTBy6WJlEpB_0nN35OH1p1ps9ng6j8,108
+qpytorch/models/qeplvm/__init__.py,sha256=GtRJb6AknTNT0epZacscrcu9itNW24GXFh0gwFw_QMM,266
+qpytorch/models/qeplvm/bayesian_qeplvm.py,sha256=Czs6yfBxNiD3a4AwAErw6gXA0b16eUIOOS1Kn7pbvxA,1625
+qpytorch/models/qeplvm/latent_variable.py,sha256=Oz0MZNg0_GPsMr0h0K8rrFPjUr76GgfJamuUQAUCFWc,3659
+qpytorch/optim/__init__.py,sha256=CcL6qsxuzrGMYWb4Tj2bhu6oNCMMZoBxfXkl162nskw,78
+qpytorch/priors/__init__.py,sha256=FQlqEd7C9Uib44inp4HUq-2o8wcLcdLUAgrY1GxUSmU,1031
+qpytorch/priors/qep_priors.py,sha256=9KFm62XuceheMAdHtSqOdq3O2xqtzdStaoCYp6giSMk,2840
+qpytorch/test/__init__.py,sha256=HNZWJRqUxAFxegg4etHcYSw4Zu9XBbe1dxIzNbhWkNY,730
+qpytorch/test/base_likelihood_test_case.py,sha256=_XtpflusvDOuhzEB0hElgQdB5QkIMcCaq3SdjXVmg6k,4634
+qpytorch/test/model_test_case.py,sha256=V0H50k6NAl7ikn5M6orFW3ORukIKpLO-2ECn352hqHA,6405
+qpytorch/test/variational_test_case.py,sha256=8WA2Kr5krlWgAsACHwsnOpgfRrUyPPGn-iXrEkNQnTc,17085
+qpytorch/utils/__init__.py,sha256=DlpoQfY0COkeWmW8f0KMZyNsNiJMBEs5Z-nlbs8pdxo,1001
+qpytorch/utils/warnings.py,sha256=HMrlnT1cK6twx4m1dTHnqx2PTBvuzmqxk567YxYk8co,826
+qpytorch/variational/__init__.py,sha256=b8T3yzFTPMhssoPmgygacD-Zh55b7SFqLLUtTB-BIpU,2367
+qpytorch/variational/_variational_distribution.py,sha256=ZFKFbvV0-USC8NAWAdXN-_0HpGdwM9K66sBm7eTXnh0,2014
+qpytorch/variational/_variational_strategy.py,sha256=fCFUSuTOjRrB-tHztC93_4sczQvILTN4WS68Ot1iJUA,18736
+qpytorch/variational/additive_grid_interpolation_variational_strategy.py,sha256=i9qRRCLlv341wGHdcqX8oesBtT10qmMZvn-U_YuhpyI,3984
+qpytorch/variational/batch_decoupled_variational_strategy.py,sha256=kc2Z3NVbEuaWZ_hHxfSX2jKyuYsPzI6QPrVIzHRUxrg,12998
+qpytorch/variational/cholesky_variational_distribution.py,sha256=7RDdUqu3iwr0EQySJ-OHQOQq4_LlU8rC2LioW_dTRD0,3347
+qpytorch/variational/ciq_variational_strategy.py,sha256=UR2_SILO7MunHQX30O_mUiEylZxBhHiWBAE-k7Ps6Pc,15481
+qpytorch/variational/delta_variational_distribution.py,sha256=OBhbMthojkxFKbdArRkrqeHrGrZbfd_8h9PMgwWlJsg,1924
+qpytorch/variational/grid_interpolation_variational_strategy.py,sha256=a_Ow8XVup5FwHXaq2pOC9svKNVwqRMvRRGwRf6fP754,5435
+qpytorch/variational/independent_multitask_variational_strategy.py,sha256=nm7T_FykWdRp0BS2sumy48WRW05YCRmbSECw-4k2hU8,5091
+qpytorch/variational/lmc_variational_strategy.py,sha256=qx_jvmWP0p2Fkf7SP7I5f-_LIs3ti-pOlwu2x74vhcI,12646
+qpytorch/variational/mean_field_variational_distribution.py,sha256=DtH7thw7llrnjpuoOukb4bGTZTpuOyaDik8nPJZzyss,3241
+qpytorch/variational/multitask_variational_strategy.py,sha256=DTMIqlu7WfxOejK4YL5T3OwYddmihorFMwQlOyQl1m8,16165
+qpytorch/variational/natural_variational_distribution.py,sha256=RT1NqZbTjGAbRfiOKp7rgQ2ACwMz3WG1xOX2yR1bzKE,6557
+qpytorch/variational/nearest_neighbor_variational_strategy.py,sha256=RAtEVpZSOeuQk8v-r8GZKl_at-piNScBdhCGjX1gDQY,26072
+qpytorch/variational/orthogonally_decoupled_variational_strategy.py,sha256=I2YL4M5BIzaVdZfGKFYSyhBGPv_9POQkYmvqdbrI7UQ,6024
+qpytorch/variational/tril_natural_variational_distribution.py,sha256=3wPggMUY2935HTO1mW2GH7ceDKOHQsSDaIbt05W72ec,6020
+qpytorch/variational/uncorrelated_multitask_variational_strategy.py,sha256=LdiVacUdQZ-BJDGcdHwlZ_uIVPfRl1WAgEtfs3ahxdg,5176
+qpytorch/variational/unwhitened_variational_strategy.py,sha256=068ScAOHk0VHLfkwakR41vrpASqIDjvvnhOFYIEE9uU,10713
+qpytorch/variational/variational_strategy.py,sha256=TD_rPpQL2n7bK869tICT6cA0cc0YFgqi0AsHfyVo2Zc,13155
+qpytorch-0.1.dist-info/LICENSE,sha256=QcK8fAvGl70vlwIHUqKdi4oV_SvhC6lBGYXTR1znTsY,1067
+qpytorch-0.1.dist-info/METADATA,sha256=pOhOSsJjOL6qc4tSYFILwL-ZUN9dKgS4OhbqfjWfDHs,7986
+qpytorch-0.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+qpytorch-0.1.dist-info/top_level.txt,sha256=WZP9m4PVYtj2RhzbzmW4UqUGOy-sOfumPrjnvNFrv4Q,9
+qpytorch-0.1.dist-info/RECORD,,

qpytorch-0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.45.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qpytorch-0.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+qpytorch