`leaspy.models.noise_models`.GaussianDiagonalNoiseModel

class GaussianDiagonalNoiseModel(parameters: Dict[str, Tensor] | None = None, scale_dimension: int | None = None)

Bases: AbstractGaussianNoiseModel

Class implementing diagonal Gaussian noise models.

Parameters:

parametersdict [ str, torch.Tensor ] or None: Values for all the free parameters of the distribution family. All of them must have values before using the sampling methods.
scale_dimensionint, optional: The scale dimension.

Attributes:

scale_dimensionint, optional: The scale dimension.
parametersdict: Contains the parameters relative to the noise model.

Methods

`compute_canonical_loss`(data, predictions)	Compute a human-friendly overall loss (RMSE).
`compute_l2_residuals`(data, predictions)	Compute the squared residuals of the given predictions.
`compute_nll`(data, predictions, *[, ...])	Negative log-likelihood without summation (and its gradient w.r.t.
`compute_residuals`(data, predictions)	Compute the residuals of the given predictions.
`compute_rmse`(data, predictions)	Computes root mean squared error of provided data vs.
`compute_sufficient_statistics`(data, predictions)	Compute the specific sufficient statistics and metrics for this noise-model.
`factory`	alias of `Normal`
`move_to_device`(device)	Move all torch tensors stored in this instance to the provided device (parameters & hyperparameters).
`raise_if_partially_defined`()	Raise an error if some of the free parameters are not defined.
`raise_if_unknown_parameters`(params)	Raise an error if the provided parameters are not part of the free parameters.
`rv_around`(loc)	Return the torch distribution centred around values (only if noise is not None).
`sample_around`(loc)	Realization around loc with respect to partially defined distribution.
`sampler_around`(loc)	Return the sampling function around input values.
`to_dict`()	Serialize instance as dictionary.
`update_parameters`(*[, validate])	(Partial) update of the free parameters of the distribution family.
`update_parameters_from_predictions`(data, ...)	In-place update of free parameters from provided predictions.
`update_parameters_from_sufficient_statistics`(...)	In-place update of free parameters from provided sufficient statistics.
`validate`(**params)	Validation function for parameters (based on 'validate_xxx' methods).
`validate_scale`(scale)	Ensure the scale is valid.

classmethod compute_canonical_loss(data: Dataset, predictions: Tensor) → Tensor

Compute a human-friendly overall loss (RMSE).

Parameters:

dataDataset: The dataset related to the computation of the log likelihood.
predictionstorch.Tensor: The model’s predictions from which to compute the canonical loss.

Returns:

torch.Tensor: The computed loss.

classmethod compute_l2_residuals(data: Dataset, predictions: Tensor) → Tensor

Compute the squared residuals of the given predictions.

Parameters:

dataDataset: The dataset related to the computation of the squared residuals.
predictionstorch.Tensor: The model’s predictions from which to compute the squared residuals.

Returns:

torch.Tensor: The squared residuals.

compute_nll(data: Dataset, predictions: Tensor, *, with_gradient: bool = False) → Tensor | Tuple[Tensor, Tensor]

Negative log-likelihood without summation (and its gradient w.r.t. predictions if requested).

Parameters:

dataDataset: The dataset related to the computation of the log likelihood.
predictionstorch.Tensor: The model’s predictions from which to compute the log likelihood.
with_gradientbool, optional: If True, returns also the gradient of the negative log likelihood wrt the predictions. If False, only returns the negative log likelihood. Default=False.

Returns:

torch.Tensor or tuple of torch.Tensor: The negative log likelihood (and its jacobian if requested).

static compute_residuals(data: Dataset, predictions: Tensor) → Tensor

Compute the residuals of the given predictions.

Parameters:

dataDataset: The dataset related to the computation of the residuals.
predictionstorch.Tensor: The model’s predictions from which to compute the residuals.

Returns:

torch.Tensor: The residuals.

classmethod compute_rmse(data: Dataset, predictions: Tensor) → Tensor

Computes root mean squared error of provided data vs. predictions.

Parameters:

dataDataset: The dataset related to the computation of the root mean squared error.
predictionstorch.Tensor: The model’s predictions from which to compute the root mean squared error.

Returns:

torch.Tensor: The root mean squared error.

compute_sufficient_statistics(data: Dataset, predictions: Tensor) → Dict[str, Tensor]

Compute the specific sufficient statistics and metrics for this noise-model.

Parameters:

dataDataset: The dataset related to the computation of the sufficient statistics.
predictionstorch.Tensor: The model’s predictions from which to compute the sufficient statistics.

Returns:

DictParamsTorch: The sufficient statistics.

factory: alias of Normal

move_to_device(device: device) → None

Move all torch tensors stored in this instance to the provided device (parameters & hyperparameters).

Parameters:

devicetorch.device: Torch device on which to move the tensors.

raise_if_partially_defined() → None: Raise an error if some of the free parameters are not defined.

classmethod raise_if_unknown_parameters(params: Iterable | None) → None

Raise an error if the provided parameters are not part of the free parameters.

Parameters:

paramsIterable, optional: The list of parameters to analyze.

rv_around(loc: Tensor) → Distribution

Return the torch distribution centred around values (only if noise is not None).

Parameters:

loctorch.Tensor: The loc around which to sample.

Returns:

torch.distributions.distribution.Distribution: The torch distribution centered around the loc.

sample_around(loc: Tensor) → Tensor

Realization around loc with respect to partially defined distribution.

Parameters:

loctorch.Tensor: The loc around which to sample.

Returns:

torch.Tensor: The requested sample.

sampler_around(loc: Tensor) → Callable[[], Tensor]

Return the sampling function around input values.

Parameters:

loctorch.Tensor: The loc around which to sample.

Returns:

Callable: The sampler.

to_dict() → Dict[str, Any]

Serialize instance as dictionary.

Returns:

KwargsType: The instance serialized as a dictionary.

update_parameters(*, validate: bool = False, **parameters: Tensor) → None

(Partial) update of the free parameters of the distribution family.

Parameters:

validatebool, optional: If True, the provided parameters are validated before being updated. Default=False.
**parameterstorch.Tensor: The new parameters.

update_parameters_from_predictions(data: Dataset, predictions: Tensor) → None

In-place update of free parameters from provided predictions.

Parameters:

dataDataset: The dataset related to the computation of the log likelihood.
predictionstorch.Tensor: The model’s predictions from which to update the parameters.

update_parameters_from_sufficient_statistics(data: Dataset, sufficient_statistics: Dict[str, Tensor]) → None

In-place update of free parameters from provided sufficient statistics.

Parameters:

dataDataset: The dataset related to the computation of the log likelihood.
sufficient_statisticsDictParamsTorch: The sufficient statistics to use for parameter update.

validate(**params: Any) → Dict[str, Tensor]

Validation function for parameters (based on ‘validate_xxx’ methods).

Parameters:

**paramsAny: The parameters to validate.

Returns:

DictParamsTorch: The validated parameters.

validate_scale(scale: Tensor) → Tensor

Ensure the scale is valid.

Parameters:

scaletorch.Tensor: The scale to validate.

Returns:

torch.Tensor: The validated scale.

leaspy.models.noise_models.GaussianDiagonalNoiseModel

`leaspy.models.noise_models`.GaussianDiagonalNoiseModel