inference

type BetaLikelihoodDistribution ¶

type BetaLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

BetaLikelihoodDistribution implements a Beta distribution likelihood model for bounded continuous data analysis and parameter estimation.

The Beta distribution is particularly useful for modeling data that is bounded between 0 and 1, such as proportions, probabilities, rates, and normalized measurements. It provides flexible shape modeling through its two shape parameters α (alpha) and β (beta).

Mathematical Background: The Beta distribution Beta(α, β) has probability density function:

f(x | α, β) = x^(α-1) * (1-x)^(β-1) / B(α, β)

where B(α, β) is the Beta function, and x ∈ [0, 1].

Key Properties:

• Support: x ∈ [0, 1] (bounded continuous)
• Shape parameters: α > 0, β > 0 (both must be positive)
• Mean: E[X] = α / (α + β)
• Variance: Var[X] = (α * β) / ((α + β)² * (α + β + 1))
• Special cases:
• α = β = 1: Uniform distribution on [0, 1]
• α = 1, β = 1: Uniform distribution
• α > 1, β > 1: Bell-shaped distribution
• α < 1, β < 1: U-shaped distribution

Applications:

• Proportion modeling: Success rates, conversion rates, market shares
• Probability estimation: Bayesian inference with Beta priors
• Quality control: Defect rates, pass/fail proportions
• Financial modeling: Recovery rates, default probabilities
• Machine learning: Classification confidence scores

Parameter Configuration: The distribution can be configured in two ways:

1. Direct parameters: Provide "alpha" and "beta" parameters directly
2. Mean-variance: Provide "mean" and "variance" parameters for automatic conversion

Example:

dist := &BetaLikelihoodDistribution{}
dist.SetSeed(0, settings)
// Configure with mean=0.3, variance=0.05
dist.SetParams(params, partitionIndex, stateHistories, timestepsHistory)

// Evaluate likelihood of observed proportions
logLike := dist.EvaluateLogLike([]float64{0.25, 0.35, 0.28})

Performance:

• O(d) time complexity where d is the data dimension
• Memory usage: O(d) for parameter storage
• Efficient for moderate dimensions (< 1000)

func (b *BetaLikelihoodDistribution) EvaluateLogLike(
	data []float64,
) float64

func (b *BetaLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (b *BetaLikelihoodDistribution) GenerateNewSamples() []float64

func (b *BetaLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (b *BetaLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type DataComparisonGradientIteration ¶

type DataComparisonGradientIteration struct {
	Likelihood   LikelihoodDistributionWithGradient
	GradientFunc func(
		params *simulator.Params,
		likeMeanGrad []float64,
	) []float64
	Batch *simulator.StateHistory
}

DataComparisonGradientIteration allows for any log-likelihood gradient to be used in computing the overall comparison distribution gradient.

func (d *DataComparisonGradientIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (d *DataComparisonGradientIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

func (d *DataComparisonGradientIteration) UpdateMemory(
	params *simulator.Params,
	update general.StateMemoryUpdate,
)

type DataComparisonIteration ¶

type DataComparisonIteration struct {
	Likelihood LikelihoodDistribution
	// contains filtered or unexported fields
}

DataComparisonIteration allows for any log-likelihood to be used as a comparison distribution between data values, a mean vector and covariance matrix.

func (d *DataComparisonIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (d *DataComparisonIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

type DataGenerationIteration ¶

type DataGenerationIteration struct {
	Likelihood LikelihoodDistribution
	// contains filtered or unexported fields
}

DataGenerationIteration allows for any likelihood to be used as a data generation distribution based on a mean and covariance matrix.

func (d *DataGenerationIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (d *DataGenerationIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

type GammaLikelihoodDistribution ¶

type GammaLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

GammaLikelihoodDistribution assumes the real data are well described by a gamma distribution, given the input mean and variance.

func (g *GammaLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (g *GammaLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (g *GammaLikelihoodDistribution) GenerateNewSamples() []float64

func (g *GammaLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (g *GammaLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type LikelihoodDistribution ¶

type LikelihoodDistribution interface {
	SetSeed(partitionIndex int, settings *simulator.Settings)
	SetParams(
		params *simulator.Params,
		partitionIndex int,
		stateHistories []*simulator.StateHistory,
		timestepsHistory *simulator.CumulativeTimestepsHistory,
	)
	EvaluateLogLike(data []float64) float64
	GenerateNewSamples() []float64
}

LikelihoodDistribution defines a likelihood model over observed data for statistical inference and parameter estimation.

This interface represents a probability distribution that can evaluate the likelihood of observed data given parameters and generate new samples from the distribution. It serves as the foundation for Bayesian inference, parameter estimation, and model validation in stochadex simulations.

Mathematical Concept: A likelihood distribution represents the probability model p(data | parameters), where the likelihood function measures how well the model explains observed data given specific parameter values. This is fundamental to:

• Maximum likelihood estimation: θ̂ = argmax_θ p(data | θ)
• Bayesian inference: p(θ | data) ∝ p(data | θ) × p(θ)
• Model comparison and selection
• Parameter uncertainty quantification

Interface Methods:

• SetSeed: Initialize random number generator state for reproducible sampling
• SetParams: Configure distribution parameters from simulation context
• EvaluateLogLike: Compute log-likelihood log p(data | params) for given data
• GenerateNewSamples: Draw new samples from the current parameter configuration

Implementation Requirements:

• SetSeed must be called before any other methods
• SetParams must be called before EvaluateLogLike or GenerateNewSamples
• EvaluateLogLike should return log-likelihood (not raw likelihood) for numerical stability
• GenerateNewSamples should return samples consistent with current parameters

Example Usage:

dist := &BetaLikelihoodDistribution{}
dist.SetSeed(0, settings)
dist.SetParams(params, partitionIndex, stateHistories, timestepsHistory)

// Evaluate likelihood of observed data
logLike := dist.EvaluateLogLike(observedData)

// Generate new samples for validation
newSamples := dist.GenerateNewSamples()

Related Types:

• See LikelihoodDistributionWithGradient for gradient-based optimization
• See BetaLikelihoodDistribution for beta distribution implementation
• See NormalLikelihoodDistribution for normal distribution implementation

type LikelihoodDistributionWithGradient ¶

type LikelihoodDistributionWithGradient interface {
	LikelihoodDistribution
	EvaluateLogLikeMeanGrad(data []float64) []float64
}

LikelihoodDistributionWithGradient extends LikelihoodDistribution with a mean gradient for optimisation.

type NegativeBinomialLikelihoodDistribution ¶

type NegativeBinomialLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

NegativeBinomialLikelihoodDistribution assumes the real data are well described by a negative binomial distribution, given the input mean and variance.

func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLike(
	data []float64,
) float64

func (n *NegativeBinomialLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (n *NegativeBinomialLikelihoodDistribution) GenerateNewSamples() []float64

func (n *NegativeBinomialLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (n *NegativeBinomialLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type NormalLikelihoodDistribution ¶

type NormalLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

NormalLikelihoodDistribution models data with a multivariate normal.

Usage hints:

• Provide mean/covariance via params or upstream partition outputs.
• Optional: "default_covariance" used if provided covariance is not PD.
• GenerateNewSamples draws from the current parameterised distribution.

func (n *NormalLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (n *NormalLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (n *NormalLikelihoodDistribution) GenerateNewSamples() []float64

func (n *NormalLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (n *NormalLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type PoissonLikelihoodDistribution ¶

type PoissonLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

PoissonLikelihoodDistribution models count data with a Poisson distribution.

Usage hints:

• Provide mean via params or upstream partition outputs.
• GenerateNewSamples draws iid Poisson variates per dimension.

func (p *PoissonLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (p *PoissonLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (p *PoissonLikelihoodDistribution) GenerateNewSamples() []float64

func (p *PoissonLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (p *PoissonLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type PosteriorCovarianceIteration ¶

type PosteriorCovarianceIteration struct {
}

PosteriorCovarianceIteration updates an estimate of the covariance matrix of the posterior distribution over params using log-likelihood and param values given in the state history of other partitions, and a mean vector.

func (p *PosteriorCovarianceIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (p *PosteriorCovarianceIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

type PosteriorLogNormalisationIteration ¶

type PosteriorLogNormalisationIteration struct {
}

PosteriorLogNormalisationIteration updates the cumulative normalisation of the posterior distribution over params using log-likelihood values given in the state history of other partitions as well as a specified past discounting factor.

func (p *PosteriorLogNormalisationIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (p *PosteriorLogNormalisationIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

type PosteriorMeanIteration ¶

type PosteriorMeanIteration struct {
	Transform func(
		params *simulator.Params,
		values mat.Vector,
	) mat.Vector
}

PosteriorMeanIteration updates an estimate of the mean of the posterior distribution over params using log-likelihood and param values given in the state history of other partitions.

func (p *PosteriorMeanIteration) Configure(
	partitionIndex int,
	settings *simulator.Settings,
)

func (p *PosteriorMeanIteration) Iterate(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
) []float64

type TLikelihoodDistribution ¶

type TLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

TLikelihoodDistribution assumes the real data are well described by a Student's t-distribution, given the input degrees of freedom, mean and covariance matrix.

func (t *TLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (t *TLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (t *TLikelihoodDistribution) GenerateNewSamples() []float64

func (t *TLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (t *TLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)

type WishartLikelihoodDistribution ¶

type WishartLikelihoodDistribution struct {
	Src rand.Source
	// contains filtered or unexported fields
}

WishartLikelihoodDistribution assumes the real data are well described by a Wishart distribution, given the input degrees of freedom and scale matrix.

func (w *WishartLikelihoodDistribution) EvaluateLogLike(data []float64) float64

func (w *WishartLikelihoodDistribution) EvaluateLogLikeMeanGrad(
	data []float64,
) []float64

func (w *WishartLikelihoodDistribution) GenerateNewSamples() []float64

func (w *WishartLikelihoodDistribution) SetParams(
	params *simulator.Params,
	partitionIndex int,
	stateHistories []*simulator.StateHistory,
	timestepsHistory *simulator.CumulativeTimestepsHistory,
)

func (w *WishartLikelihoodDistribution) SetSeed(
	partitionIndex int,
	settings *simulator.Settings,
)