API
GPLikelihoods.BernoulliLikelihoodGPLikelihoods.BijectiveSimplexLinkGPLikelihoods.CategoricalLikelihoodGPLikelihoods.ChainLinkGPLikelihoods.ExpLinkGPLikelihoods.ExponentialLikelihoodGPLikelihoods.GammaLikelihoodGPLikelihoods.GaussianLikelihoodGPLikelihoods.HeteroscedasticGaussianLikelihoodGPLikelihoods.InvLinkGPLikelihoods.LinkGPLikelihoods.LogLinkGPLikelihoods.LogisticLinkGPLikelihoods.LogitLinkGPLikelihoods.NBParamFailureGPLikelihoods.NBParamIGPLikelihoods.NBParamIIGPLikelihoods.NBParamPowerGPLikelihoods.NBParamSuccessGPLikelihoods.NegativeBinomialLikelihoodGPLikelihoods.NormalCDFLinkGPLikelihoods.PoissonLikelihoodGPLikelihoods.ProbitLinkGPLikelihoods.SoftMaxLinkGPLikelihoods.SqrtLinkGPLikelihoods.SquareLinkGPLikelihoods.expected_loglikelihood
Likelihoods
GPLikelihoods.BernoulliLikelihood — TypeBernoulliLikelihood(l=logistic)Bernoulli likelihood is to be used if we assume that the uncertainity associated with the data follows a Bernoulli distribution. The link l needs to transform the input f to the domain [0, 1]
\[ p(y|f) = \operatorname{Bernoulli}(y | l(f))\]
On calling, this would return a Bernoulli distribution with l(f) probability of true.
GPLikelihoods.CategoricalLikelihood — TypeCategoricalLikelihood(l=BijectiveSimplexLink(softmax))Categorical likelihood is to be used if we assume that the uncertainty associated with the data follows a Categorical distribution.
Assuming a distribution with n categories:
n-1 inputs (bijective link)
One can work with a bijective transformation by wrapping a link (like softmax) into a BijectiveSimplexLink and only needs n-1 inputs:
\[ p(y|f_1, f_2, \dots, f_{n-1}) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_{n-1}, 0))\]
The default constructor is a bijective link around softmax.
n inputs (non-bijective link)
One can also pass directly the inputs without concatenating a 0:
\[ p(y|f_1, f_2, \dots, f_n) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_n))\]
This variant is over-parametrized, as there are n-1 independent parameters embedded in a n dimensional parameter space. For more details, see the end of the section of this Wikipedia link where it corresponds to Variant 1 and 2.
GPLikelihoods.ExponentialLikelihood — TypeExponentialLikelihood(l=exp)Exponential likelihood with scale given by l(f).
\[ p(y|f) = \operatorname{Exponential}(y | l(f))\]
GPLikelihoods.GammaLikelihood — TypeGammaLikelihood(α::Real=1.0, l=exp)Gamma likelihood with fixed shape α.
\[ p(y|f) = \operatorname{Gamma}(y | α, l(f))\]
On calling, this returns a Gamma distribution with shape α and scale invlink(f).
GPLikelihoods.GaussianLikelihood — TypeGaussianLikelihood(σ²)Gaussian likelihood with σ² variance. This is to be used if we assume that the uncertainity associated with the data follows a Gaussian distribution.
\[ p(y|f) = \operatorname{Normal}(y | f, σ²)\]
On calling, this would return a normal distribution with mean f and variance σ².
GPLikelihoods.HeteroscedasticGaussianLikelihood — TypeHeteroscedasticGaussianLikelihood(l=exp)Heteroscedastic Gaussian likelihood. This is a Gaussian likelihood whose mean and variance are functions of latent processes.
\[ p(y|[f, g]) = \operatorname{Normal}(y | f, sqrt(l(g)))\]
On calling, this would return a normal distribution with mean f and variance l(g). Where l is link going from R to R^+
GPLikelihoods.PoissonLikelihood — TypePoissonLikelihood(l=exp)Poisson likelihood with rate defined as l(f).
\[ p(y|f) = \operatorname{Poisson}(y | θ=l(f))\]
This is to be used if we assume that the uncertainity associated with the data follows a Poisson distribution.
Negative Binomial
GPLikelihoods.NegativeBinomialLikelihood — TypeNegativeBinomialLikelihood(param::NBParam, invlink::Union{Function,Link})There are many possible parametrizations for the Negative Binomial likelihood. We follow the convention laid out in p.137 of [^Hilbe'11] and provide some common parametrizations. The NegativeBinomialLikelihood has a special structure; the first type parameter NBParam defines in what parametrization the latent function is used, and contains the other (scalar) parameters. NBParam itself has two subtypes:
NBParamProbfor parametrizations wheref -> p, the probability of success of a Bernoulli eventNBParamMeanfor parametrizations wheref -> μ, the expected number of events
NBParam predefined types
NBParamProb types with p = invlink(f) the probability of success or failure
NBParamSuccess: Herep = invlink(f)is the probability of success. This is the definition used inDistributions.jl.NBParamFailure: Herep = invlink(f)is the probability of a failure
NBParamMean types with μ = invlink(f) the mean/expected number of events
NBParamI: Mean is linked tofand variance is given byμ(1 + α)NBParamII: Mean is linked tofand variance is given byμ(1 + α * μ)NBParamPower: Mean is linked tofand variance is given byμ(1 + α * μ^ρ)
To create a new parametrization, you need to:
- create a new type
struct MyNBParam{T} <: NBParam; myparams::T; end; - dispatch
(l::NegativeBinomialLikelihood{<:MyNBParam})(f::Real), which must return aNegativeBinomialfromDistributions.jl.
NegativeBinomial follows the parametrization of NBParamSuccess, i.e. the first argument is the number of successes and the second argument is the probability of success.
Examples
julia> NegativeBinomialLikelihood(NBParamSuccess(10), logistic)(2.0)
+API · GPLikelihoods.jl
+
+
+
+
+
+API
GPLikelihoods.BernoulliLikelihoodGPLikelihoods.BijectiveSimplexLinkGPLikelihoods.CategoricalLikelihoodGPLikelihoods.ChainLinkGPLikelihoods.ExpLinkGPLikelihoods.ExponentialLikelihoodGPLikelihoods.GammaLikelihoodGPLikelihoods.GaussianLikelihoodGPLikelihoods.HeteroscedasticGaussianLikelihoodGPLikelihoods.InvLinkGPLikelihoods.LinkGPLikelihoods.LogLinkGPLikelihoods.LogisticLinkGPLikelihoods.LogitLinkGPLikelihoods.NBParamFailureGPLikelihoods.NBParamIGPLikelihoods.NBParamIIGPLikelihoods.NBParamPowerGPLikelihoods.NBParamSuccessGPLikelihoods.NegativeBinomialLikelihoodGPLikelihoods.NormalCDFLinkGPLikelihoods.PoissonLikelihoodGPLikelihoods.ProbitLinkGPLikelihoods.SoftMaxLinkGPLikelihoods.SqrtLinkGPLikelihoods.SquareLinkGPLikelihoods.expected_loglikelihood
Likelihoods
GPLikelihoods.BernoulliLikelihood — TypeBernoulliLikelihood(l=logistic)
Bernoulli likelihood is to be used if we assume that the uncertainity associated with the data follows a Bernoulli distribution. The link l needs to transform the input f to the domain [0, 1]
\[ p(y|f) = \operatorname{Bernoulli}(y | l(f))\]
On calling, this would return a Bernoulli distribution with l(f) probability of true.
sourceGPLikelihoods.CategoricalLikelihood — TypeCategoricalLikelihood(l=BijectiveSimplexLink(softmax))
Categorical likelihood is to be used if we assume that the uncertainty associated with the data follows a Categorical distribution.
Assuming a distribution with n categories:
n-1 inputs (bijective link)
One can work with a bijective transformation by wrapping a link (like softmax) into a BijectiveSimplexLink and only needs n-1 inputs:
\[ p(y|f_1, f_2, \dots, f_{n-1}) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_{n-1}, 0))\]
The default constructor is a bijective link around softmax.
n inputs (non-bijective link)
One can also pass directly the inputs without concatenating a 0:
\[ p(y|f_1, f_2, \dots, f_n) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_n))\]
This variant is over-parametrized, as there are n-1 independent parameters embedded in a n dimensional parameter space. For more details, see the end of the section of this Wikipedia link where it corresponds to Variant 1 and 2.
sourceGPLikelihoods.ExponentialLikelihood — TypeExponentialLikelihood(l=exp)
Exponential likelihood with scale given by l(f).
\[ p(y|f) = \operatorname{Exponential}(y | l(f))\]
sourceGPLikelihoods.GammaLikelihood — TypeGammaLikelihood(α::Real=1.0, l=exp)
Gamma likelihood with fixed shape α.
\[ p(y|f) = \operatorname{Gamma}(y | α, l(f))\]
On calling, this returns a Gamma distribution with shape α and scale invlink(f).
sourceGPLikelihoods.GaussianLikelihood — TypeGaussianLikelihood(σ²)
Gaussian likelihood with σ² variance. This is to be used if we assume that the uncertainity associated with the data follows a Gaussian distribution.
\[ p(y|f) = \operatorname{Normal}(y | f, σ²)\]
On calling, this would return a normal distribution with mean f and variance σ².
sourceGPLikelihoods.HeteroscedasticGaussianLikelihood — TypeHeteroscedasticGaussianLikelihood(l=exp)
Heteroscedastic Gaussian likelihood. This is a Gaussian likelihood whose mean and variance are functions of latent processes.
\[ p(y|[f, g]) = \operatorname{Normal}(y | f, sqrt(l(g)))\]
On calling, this would return a normal distribution with mean f and variance l(g). Where l is link going from R to R^+
sourceGPLikelihoods.PoissonLikelihood — TypePoissonLikelihood(l=exp)
Poisson likelihood with rate defined as l(f).
\[ p(y|f) = \operatorname{Poisson}(y | θ=l(f))\]
This is to be used if we assume that the uncertainity associated with the data follows a Poisson distribution.
sourceNegative Binomial
GPLikelihoods.NegativeBinomialLikelihood — TypeNegativeBinomialLikelihood(param::NBParam, invlink::Union{Function,Link})
There are many possible parametrizations for the Negative Binomial likelihood. We follow the convention laid out in p.137 of [^Hilbe'11] and provide some common parametrizations. The NegativeBinomialLikelihood has a special structure; the first type parameter NBParam defines in what parametrization the latent function is used, and contains the other (scalar) parameters. NBParam itself has two subtypes:
NBParamProb for parametrizations where f -> p, the probability of success of a Bernoulli eventNBParamMean for parametrizations where f -> μ, the expected number of events
NBParam predefined types
NBParamProb types with p = invlink(f) the probability of success or failure
NBParamSuccess: Here p = invlink(f) is the probability of success. This is the definition used in Distributions.jl.NBParamFailure: Here p = invlink(f) is the probability of a failure
NBParamMean types with μ = invlink(f) the mean/expected number of events
NBParamI: Mean is linked to f and variance is given by μ(1 + α)NBParamII: Mean is linked to f and variance is given by μ(1 + α * μ)NBParamPower: Mean is linked to f and variance is given by μ(1 + α * μ^ρ)
To create a new parametrization, you need to:
- create a new type
struct MyNBParam{T} <: NBParam; myparams::T; end; - dispatch
(l::NegativeBinomialLikelihood{<:MyNBParam})(f::Real), which must return a NegativeBinomial from Distributions.jl.
NegativeBinomial follows the parametrization of NBParamSuccess, i.e. the first argument is the number of successes and the second argument is the probability of success.
Examples
julia> NegativeBinomialLikelihood(NBParamSuccess(10), logistic)(2.0)
NegativeBinomial{Float64}(r=10.0, p=0.8807970779778824)
julia> NegativeBinomialLikelihood(NBParamFailure(10), logistic)(2.0)
NegativeBinomial{Float64}(r=10.0, p=0.11920292202211757)
@@ -15,3 +475,4 @@
q_f::AbstractVector{<:Normal},
y::AbstractVector,
)
This function computes the expected log likelihood:
\[ ∫ q(f) log p(y | f) df\]
where p(y | f) is the process likelihood. This is described by lik, which should be a callable that takes f as input and returns a Distribution over y that supports loglikelihood(lik(f), y).
q(f) is an approximation to the latent function values f given by:
\[ q(f) = ∫ p(f | u) q(u) du\]
where q(u) is the variational distribution over inducing points. The marginal distributions of q(f) are given by q_f.
quadrature determines which method is used to calculate the expected log likelihood.
Extended help
q(f) is assumed to be an MvNormal distribution and p(y | f) is assumed to have independent marginals such that only the marginals of q(f) are required.
sourceexpected_loglikelihood(::DefaultExpectationMethod, lik, q_f::AbstractVector{<:Normal}, y::AbstractVector)
The expected log likelihood, using the default quadrature method for the given likelihood. (The default quadrature method is defined by default_expectation_method(lik), and should be the closed form solution if it exists, but otherwise defaults to Gauss-Hermite quadrature.)
sourceSettings
This document was generated with Documenter.jl version 0.27.25 on Sunday 14 July 2024. Using Julia version 1.10.4.
Home · GPLikelihoods.jl GPLikelihoods
GPLikelihoods.jl provides a practical interface to connect Gaussian and non-conjugate likelihoods to Gaussian Processes. The API is very basic: Every AbstractLikelihood object is a functor taking a Real or an AbstractVector as an input and returning a Distribution from Distributions.jl.
Single-latent vs multi-latent likelihoods
Most likelihoods, like the GaussianLikelihood, only require one latent Gaussian process. Passing a Real will therefore return a UnivariateDistribution, and passing an AbstractVector{<:Real} will return a multivariate product of distributions.
julia> f = 2.0;
julia> GaussianLikelihood()(f) == Normal(2.0, 1e-3)true
julia> fs = [2.0, 3.0, 1.5];
julia> GaussianLikelihood()(fs) isa AbstractMvNormaltrue
Some likelihoods, like the CategoricalLikelihood, require multiple latent Gaussian processes, and an AbstractVector{<:Real} needs to be passed. To obtain a product of distributions an AbstractVector{<:AbstractVector{<:Real}} has to be passed (we recommend using ColVecs and RowVecs from KernelFunctions.jl if you need to transform an AbstractMatrix).
julia> fs = [2.0, 3.0, 4.5];
julia> CategoricalLikelihood()(fs) isa Categoricaltrue
julia> Fs = [rand(3) for _ in 1:4];
julia> CategoricalLikelihood()(Fs) isa Product{<:Any,<:Categorical}true
Constrained parameters
The function values f of the latent Gaussian process live in the real domain $\mathbb{R}$. For some likelihoods, the domain of the distribution parameter p that is modulated by the latent Gaussian process is constrained to some subset of $\mathbb{R}$, e.g. only positive values or values in an interval.
To connect these two domains, a transformation from f to p is required. For this, we provide the Link type, which can be passed to the likelihood constructors. (Alternatively, functions can also directly be passed and will be wrapped in a Link.)
We typically call this passed transformation the invlink. This comes from the statistics literature, where the "link" is defined as f = link(p), whereas here we need p = invlink(f).
For more details about which likelihoods require a Link check out their docs.
A classical example is the BernoulliLikelihood for classification, with the probability parameter $p \in [0, 1]$. The default is to use a logistic transformation, but one could also use the inverse of the probit link:
julia> f = 2.0;
julia> BernoulliLikelihood()(f) == Bernoulli(logistic(f))true
julia> BernoulliLikelihood(NormalCDFLink())(f) == Bernoulli(normcdf(f))true
Note that we passed the inverse of the probit function which is the normcdf function.
Settings
This document was generated with Documenter.jl version 0.27.25 on Sunday 14 July 2024. Using Julia version 1.10.4.
Home · GPLikelihoods.jl
+
+
+
+
+
+GPLikelihoods
GPLikelihoods.jl provides a practical interface to connect Gaussian and non-conjugate likelihoods to Gaussian Processes. The API is very basic: Every AbstractLikelihood object is a functor taking a Real or an AbstractVector as an input and returning a Distribution from Distributions.jl.
Single-latent vs multi-latent likelihoods
Most likelihoods, like the GaussianLikelihood, only require one latent Gaussian process. Passing a Real will therefore return a UnivariateDistribution, and passing an AbstractVector{<:Real} will return a multivariate product of distributions.
julia> f = 2.0;
julia> GaussianLikelihood()(f) == Normal(2.0, 1e-3)true
julia> fs = [2.0, 3.0, 1.5];
julia> GaussianLikelihood()(fs) isa AbstractMvNormaltrue
Some likelihoods, like the CategoricalLikelihood, require multiple latent Gaussian processes, and an AbstractVector{<:Real} needs to be passed. To obtain a product of distributions an AbstractVector{<:AbstractVector{<:Real}} has to be passed (we recommend using ColVecs and RowVecs from KernelFunctions.jl if you need to transform an AbstractMatrix).
julia> fs = [2.0, 3.0, 4.5];
julia> CategoricalLikelihood()(fs) isa Categoricaltrue
julia> Fs = [rand(3) for _ in 1:4];
julia> CategoricalLikelihood()(Fs) isa Product{<:Any,<:Categorical}true
Constrained parameters
The function values f of the latent Gaussian process live in the real domain $\mathbb{R}$. For some likelihoods, the domain of the distribution parameter p that is modulated by the latent Gaussian process is constrained to some subset of $\mathbb{R}$, e.g. only positive values or values in an interval.
To connect these two domains, a transformation from f to p is required. For this, we provide the Link type, which can be passed to the likelihood constructors. (Alternatively, functions can also directly be passed and will be wrapped in a Link.)
We typically call this passed transformation the invlink. This comes from the statistics literature, where the "link" is defined as f = link(p), whereas here we need p = invlink(f).
For more details about which likelihoods require a Link check out their docs.
A classical example is the BernoulliLikelihood for classification, with the probability parameter $p \in [0, 1]$. The default is to use a logistic transformation, but one could also use the inverse of the probit link:
julia> f = 2.0;
julia> BernoulliLikelihood()(f) == Bernoulli(logistic(f))true
julia> BernoulliLikelihood(NormalCDFLink())(f) == Bernoulli(normcdf(f))true
Note that we passed the inverse of the probit function which is the normcdf function.
Settings
This document was generated with Documenter.jl version 0.27.25 on Sunday 14 July 2024. Using Julia version 1.10.4.
Search · GPLikelihoods.jl Settings
This document was generated with Documenter.jl version 0.27.25 on Sunday 14 July 2024. Using Julia version 1.10.4.
Search · GPLikelihoods.jl
+
+
+
+
+
+Settings
This document was generated with Documenter.jl version 0.27.25 on Sunday 14 July 2024. Using Julia version 1.10.4.
API
GPLikelihoods.BernoulliLikelihoodGPLikelihoods.BijectiveSimplexLinkGPLikelihoods.CategoricalLikelihoodGPLikelihoods.ChainLinkGPLikelihoods.ExpLinkGPLikelihoods.ExponentialLikelihoodGPLikelihoods.GammaLikelihoodGPLikelihoods.GaussianLikelihoodGPLikelihoods.HeteroscedasticGaussianLikelihoodGPLikelihoods.InvLinkGPLikelihoods.LinkGPLikelihoods.LogLinkGPLikelihoods.LogisticLinkGPLikelihoods.LogitLinkGPLikelihoods.NBParamFailureGPLikelihoods.NBParamIGPLikelihoods.NBParamIIGPLikelihoods.NBParamPowerGPLikelihoods.NBParamSuccessGPLikelihoods.NegativeBinomialLikelihoodGPLikelihoods.NormalCDFLinkGPLikelihoods.PoissonLikelihoodGPLikelihoods.ProbitLinkGPLikelihoods.SoftMaxLinkGPLikelihoods.SqrtLinkGPLikelihoods.SquareLinkGPLikelihoods.expected_loglikelihood
Likelihoods
GPLikelihoods.BernoulliLikelihood — TypeBernoulliLikelihood(l=logistic)
Bernoulli likelihood is to be used if we assume that the uncertainity associated with the data follows a Bernoulli distribution. The link l needs to transform the input f to the domain [0, 1]
\[ p(y|f) = \operatorname{Bernoulli}(y | l(f))\]
On calling, this would return a Bernoulli distribution with l(f) probability of true.
sourceGPLikelihoods.CategoricalLikelihood — TypeCategoricalLikelihood(l=BijectiveSimplexLink(softmax))
Categorical likelihood is to be used if we assume that the uncertainty associated with the data follows a Categorical distribution.
Assuming a distribution with n categories:
n-1 inputs (bijective link)
One can work with a bijective transformation by wrapping a link (like softmax) into a BijectiveSimplexLink and only needs n-1 inputs:
\[ p(y|f_1, f_2, \dots, f_{n-1}) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_{n-1}, 0))\]
The default constructor is a bijective link around softmax.
n inputs (non-bijective link)
One can also pass directly the inputs without concatenating a 0:
\[ p(y|f_1, f_2, \dots, f_n) = \operatorname{Categorical}(y | l(f_1, f_2, \dots, f_n))\]
This variant is over-parametrized, as there are n-1 independent parameters embedded in a n dimensional parameter space. For more details, see the end of the section of this Wikipedia link where it corresponds to Variant 1 and 2.
sourceGPLikelihoods.ExponentialLikelihood — TypeExponentialLikelihood(l=exp)
Exponential likelihood with scale given by l(f).
\[ p(y|f) = \operatorname{Exponential}(y | l(f))\]
sourceGPLikelihoods.GammaLikelihood — TypeGammaLikelihood(α::Real=1.0, l=exp)
Gamma likelihood with fixed shape α.
\[ p(y|f) = \operatorname{Gamma}(y | α, l(f))\]
On calling, this returns a Gamma distribution with shape α and scale invlink(f).
sourceGPLikelihoods.GaussianLikelihood — TypeGaussianLikelihood(σ²)
Gaussian likelihood with σ² variance. This is to be used if we assume that the uncertainity associated with the data follows a Gaussian distribution.
\[ p(y|f) = \operatorname{Normal}(y | f, σ²)\]
On calling, this would return a normal distribution with mean f and variance σ².
sourceGPLikelihoods.HeteroscedasticGaussianLikelihood — TypeHeteroscedasticGaussianLikelihood(l=exp)
Heteroscedastic Gaussian likelihood. This is a Gaussian likelihood whose mean and variance are functions of latent processes.
\[ p(y|[f, g]) = \operatorname{Normal}(y | f, sqrt(l(g)))\]
On calling, this would return a normal distribution with mean f and variance l(g). Where l is link going from R to R^+
sourceGPLikelihoods.PoissonLikelihood — TypePoissonLikelihood(l=exp)
Poisson likelihood with rate defined as l(f).
\[ p(y|f) = \operatorname{Poisson}(y | θ=l(f))\]
This is to be used if we assume that the uncertainity associated with the data follows a Poisson distribution.
sourceNegative Binomial
GPLikelihoods.NegativeBinomialLikelihood — TypeNegativeBinomialLikelihood(param::NBParam, invlink::Union{Function,Link})
There are many possible parametrizations for the Negative Binomial likelihood. We follow the convention laid out in p.137 of [^Hilbe'11] and provide some common parametrizations. The NegativeBinomialLikelihood has a special structure; the first type parameter NBParam defines in what parametrization the latent function is used, and contains the other (scalar) parameters. NBParam itself has two subtypes:
NBParamProb for parametrizations where f -> p, the probability of success of a Bernoulli eventNBParamMean for parametrizations where f -> μ, the expected number of events
NBParam predefined types
NBParamProb types with p = invlink(f) the probability of success
NBParamSuccess: This is the definition used in Distributions.jl.NBParamFailure: This is the definition used in Wikipedia.
NBParamMean types with μ = invlink(f) the mean/expected number of events
NBParamI: Mean is linked to f and variance is given by μ(1 + α)NBParamII: Mean is linked to f and variance is given by μ(1 + α * μ)NBParamPower: Mean is linked to f and variance is given by μ(1 + α * μ^ρ)
To create a new parametrization, you need to:
- create a new type
struct MyNBParam{T} <: NBParam; myparams::T; end; - dispatch
(l::NegativeBinomialLikelihood{<:MyNBParam})(f::Real), which must return a NegativeBinomial from Distributions.jl.
NegativeBinomial follows the parametrization of NBParamSuccess, i.e. the first argument is the number of successes and the second argument is the probability of success.
Examples
julia> NegativeBinomialLikelihood(NBParamSuccess(10), logistic)(2.0)
NegativeBinomial{Float64}(r=10.0, p=0.8807970779778824)
julia> NegativeBinomialLikelihood(NBParamFailure(10), logistic)(2.0)
diff --git a/previews/PR100/index.html b/previews/PR100/index.html
index d3ed606..fd65c6e 100644
--- a/previews/PR100/index.html
+++ b/previews/PR100/index.html
@@ -459,5 +459,6 @@
});
+
GPLikelihoods
GPLikelihoods.jl provides a practical interface to connect Gaussian and non-conjugate likelihoods to Gaussian Processes. The API is very basic: Every AbstractLikelihood object is a functor taking a Real or an AbstractVector as an input and returning a Distribution from Distributions.jl.
Single-latent vs multi-latent likelihoods
Most likelihoods, like the GaussianLikelihood, only require one latent Gaussian process. Passing a Real will therefore return a UnivariateDistribution, and passing an AbstractVector{<:Real} will return a multivariate product of distributions.
julia> f = 2.0;
julia> GaussianLikelihood()(f) == Normal(2.0, 1e-3)true
julia> fs = [2.0, 3.0, 1.5];
julia> GaussianLikelihood()(fs) isa AbstractMvNormaltrue
Some likelihoods, like the CategoricalLikelihood, require multiple latent Gaussian processes, and an AbstractVector{<:Real} needs to be passed. To obtain a product of distributions an AbstractVector{<:AbstractVector{<:Real}} has to be passed (we recommend using ColVecs and RowVecs from KernelFunctions.jl if you need to transform an AbstractMatrix).
julia> fs = [2.0, 3.0, 4.5];
julia> CategoricalLikelihood()(fs) isa Categoricaltrue
julia> Fs = [rand(3) for _ in 1:4];
julia> CategoricalLikelihood()(Fs) isa Product{<:Any,<:Categorical}true
Constrained parameters
The function values f of the latent Gaussian process live in the real domain $\mathbb{R}$. For some likelihoods, the domain of the distribution parameter p that is modulated by the latent Gaussian process is constrained to some subset of $\mathbb{R}$, e.g. only positive values or values in an interval.
To connect these two domains, a transformation from f to p is required. For this, we provide the Link type, which can be passed to the likelihood constructors. (Alternatively, functions can also directly be passed and will be wrapped in a Link.)
We typically call this passed transformation the invlink. This comes from the statistics literature, where the "link" is defined as f = link(p), whereas here we need p = invlink(f).
For more details about which likelihoods require a Link check out their docs.
A classical example is the BernoulliLikelihood for classification, with the probability parameter $p \in [0, 1]$. The default is to use a logistic transformation, but one could also use the inverse of the probit link:
julia> f = 2.0;
julia> BernoulliLikelihood()(f) == Bernoulli(logistic(f))true
julia> BernoulliLikelihood(NormalCDFLink())(f) == Bernoulli(normcdf(f))true
Note that we passed the inverse of the probit function which is the normcdf function.
Settings
This document was generated with Documenter.jl version 0.27.24 on Thursday 23 February 2023. Using Julia version 1.8.5.
Settings
This document was generated with Documenter.jl version 0.27.24 on Thursday 23 February 2023. Using Julia version 1.8.5.