# Source code for zfit._loss.binnedloss

```
# Copyright (c) 2022 zfit
from __future__ import annotations
from collections.abc import Iterable
import numpy as np
import tensorflow as tf
from uhi.typing.plottable import PlottableHistogram
from .. import z
from ..core.interfaces import ZfitBinnedData, ZfitBinnedPDF, ZfitParameter
from ..core.loss import BaseLoss
from ..util import ztyping
from ..util.checks import NONE
from ..util.container import convert_to_container
from ..util.warnings import warn_advanced_feature
from ..util.ztyping import OptionsInputType, ConstraintsInputType
from ..z import numpy as znp
@z.function(wraps="tensor")
def _spd_transform(values, probs, variances):
"""Transform the data to the SPD form.
Scaled Poisson distribution from Bohm and Zech, NIMA 748 (2014) 1-6
Args:
values: Data values, the counts in each bin.
probs: Data probabilities, the expected counts in each bin.
variances: Data variances, the variances of the counts in each bin.
Returns:
The transformed probabilities and values.
"""
# Scaled Poisson distribution from Bohm and Zech, NIMA 748 (2014) 1-6
scale = values * tf.math.reciprocal_no_nan(variances)
return values * scale, probs * scale
@z.function(wraps="tensor")
def poisson_loss_calc(probs, values, log_offset=None, variances=None):
"""Calculate the Poisson log probability for a given set of data.
Args:
probs: Probabilities of the data, i.e. the expected number of events in each bin.
values: Values of the data, i.e. the number of events in each bin.
log_offset: Optional offset to be added to the loss. Useful for adding a constant to the loss to improve
numerical stability.
variances: Optional variances of the data. If not None, the Poisson loss is calculated using the
scaled Poisson distribution from Bohm and Zech, NIMA 748 (2014) 1-6
Returns:
The Poisson log probability for the given data.
"""
if variances is not None:
values, probs = _spd_transform(values, probs, variances=variances)
values += znp.asarray(1e-307, dtype=znp.float64)
probs += znp.asarray(1e-307, dtype=znp.float64)
poisson_term = tf.nn.log_poisson_loss(
values, znp.log(probs), compute_full_loss=False # TODO: correct offset
) # TODO: optimization?
if log_offset is not None:
poisson_term += log_offset
return poisson_term
class BaseBinned(BaseLoss):
def __init__(
self,
model: ztyping.BinnedPDFInputType,
data: ztyping.BinnedDataInputType,
constraints: ConstraintsInputType = None,
options: OptionsInputType = None,
):
model = convert_to_container(model)
data = convert_to_container(data)
from zfit._data.binneddatav1 import BinnedData
data = [
BinnedData.from_hist(d)
if (isinstance(d, PlottableHistogram) and not isinstance(d, ZfitBinnedData))
else d
for d in data
]
not_binned_pdf = [mod for mod in model if not isinstance(mod, ZfitBinnedPDF)]
not_binned_data = [dat for dat in data if not isinstance(dat, ZfitBinnedData)]
not_binned_pdf_msg = (
"The following PDFs are not binned but need to be. They can be wrapped in an "
f"BinnedFromUnbinnedPDF. {not_binned_pdf} "
)
not_binned_data_msg = (
"The following datasets are not binned but need to be. They can be converted to a binned "
f"using the `to_binned` method. {not_binned_data}"
)
error_msg = ""
if not_binned_pdf:
error_msg += not_binned_pdf_msg
if not_binned_data:
error_msg += not_binned_data_msg
if error_msg:
raise ValueError(error_msg)
super().__init__(
model=model,
data=data,
constraints=constraints,
fit_range=None,
options=options,
)
def create_new(
self,
model: ztyping.BinnedPDFInputType = NONE,
data: ztyping.BinnedDataInputType = NONE,
constraints: ConstraintsInputType = NONE,
options: OptionsInputType = NONE,
):
r"""Create a new binned loss of this type. This is preferrable over creating a new instance in most cases.
Internals, such as certain optimizations will be shared and therefore the loss is made comparable.
If something is not given, it will be taken from the current loss.
Args:
model: |@doc:loss.binned.init.model| Binned PDF(s) that return the normalized probability
(`rel_counts` or `counts`) for
*data* under the given parameters.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.model|
data: |@doc:loss.binned.init.data| Binned dataset that will be given to the *model*.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.data|
constraints: |@doc:loss.init.constraints| Auxiliary measurements ("constraints")
that add a likelihood term to the loss.
.. math::
\mathcal{L}(\theta) = \mathcal{L}_{unconstrained} \prod_{i} f_{constr_i}(\theta)
Usually, an auxiliary measurement -- by its very nature -S should only be added once
to the loss. zfit does not automatically deduplicate constraints if they are given
multiple times, leaving the freedom for arbitrary constructs.
Constraints can also be used to restrict the loss by adding any kinds of penalties. |@docend:loss.init.constraints|
options: |@doc:loss.init.options| Additional options (as a dict) for the loss.
Current possibilities include:
- 'subtr_const' (default True): subtract from each points
log probability density a constant that
is approximately equal to the average log probability
density in the very first evaluation before
the summation. This brings the initial loss value closer to 0 and increases,
especially for large datasets, the numerical stability.
The value will be stored ith 'subtr_const_value' and can also be given
directly.
The subtraction should not affect the minimum as the absolute
value of the NLL is meaningless. However,
with this switch on, one cannot directly compare
different likelihoods ablolute value as the constant
may differ! Use `create_new` in order to have a comparable likelihood
between different losses
These settings may extend over time. In order to make sure that a loss is the
same under the same data, make sure to use `create_new` instead of instantiating
a new loss as the former will automatically overtake any relevant constants
and behavior. |@docend:loss.init.options|
Returns:
"""
if model is NONE:
model = self.model
if data is NONE:
data = self.data
if constraints is NONE:
constraints = self.constraints
if constraints is not None:
constraints = constraints.copy()
if options is NONE:
options = self._options
if isinstance(options, dict):
options = options.copy()
return type(self)(
model=model, data=data, constraints=constraints, options=options
)
[docs]class ExtendedBinnedNLL(BaseBinned):
def __init__(
self,
model: ztyping.BinnedPDFInputType,
data: ztyping.BinnedDataInputType,
constraints: ConstraintsInputType = None,
options: OptionsInputType = None,
):
r"""Extended binned likelihood using the expected number of events per bin with a poisson probability.
|@doc:loss.init.explain.spdtransform| A scaled Poisson distribution is
used as described by Bohm and Zech, NIMA 748 (2014) 1-6 |@docend:loss.init.explain.spdtransform|
The binned likelihood is defined as
.. math::
\mathcal{L} = \product \mathcal{poiss}(N_{modelbin_i}, N_{databin_i})
= N_{databin_i}^{N_{modelbin_i}} \frac{e^{- N_{databin_i}}}{N_{modelbin_i}!}
where :math:`databin_i` is the :math:`i^{th}` bin in the data and
:math:`modelbin_i` is the :math:`i^{th}` bin of the model, the expected counts.
|@doc:loss.init.explain.simultaneous| A simultaneous fit can be performed by giving one or more `model`, `data`, to the loss. The
length of each has to match the length of the others
.. math::
\mathcal{L}_{simultaneous}(\theta | {data_0, data_1, ..., data_n})
= \prod_{i} \mathcal{L}(\theta_i, data_i)
where :math:`\theta_i` is a set of parameters and
a subset of :math:`\theta` |@docend:loss.init.explain.simultaneous|
|@doc:loss.init.explain.negativelog| For optimization purposes, it is often easier
to minimize a function and to use a log transformation. The actual loss is given by
.. math::
\mathcal{L} = - \sum_{i}^{n} ln(f(\theta|x_i))
and therefore being called "negative log ..." |@docend:loss.init.explain.negativelog|
Args:
model: |@doc:loss.binned.init.model| Binned PDF(s) that return the normalized probability
(`rel_counts` or `counts`) for
*data* under the given parameters.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.model|
data: |@doc:loss.binned.init.data| Binned dataset that will be given to the *model*.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.data|
constraints: |@doc:loss.init.constraints| Auxiliary measurements ("constraints")
that add a likelihood term to the loss.
.. math::
\mathcal{L}(\theta) = \mathcal{L}_{unconstrained} \prod_{i} f_{constr_i}(\theta)
Usually, an auxiliary measurement -- by its very nature -S should only be added once
to the loss. zfit does not automatically deduplicate constraints if they are given
multiple times, leaving the freedom for arbitrary constructs.
Constraints can also be used to restrict the loss by adding any kinds of penalties. |@docend:loss.init.constraints|
options: |@doc:loss.init.options| Additional options (as a dict) for the loss.
Current possibilities include:
- 'subtr_const' (default True): subtract from each points
log probability density a constant that
is approximately equal to the average log probability
density in the very first evaluation before
the summation. This brings the initial loss value closer to 0 and increases,
especially for large datasets, the numerical stability.
The value will be stored ith 'subtr_const_value' and can also be given
directly.
The subtraction should not affect the minimum as the absolute
value of the NLL is meaningless. However,
with this switch on, one cannot directly compare
different likelihoods ablolute value as the constant
may differ! Use `create_new` in order to have a comparable likelihood
between different losses
These settings may extend over time. In order to make sure that a loss is the
same under the same data, make sure to use `create_new` instead of instantiating
a new loss as the former will automatically overtake any relevant constants
and behavior. |@docend:loss.init.options|
"""
self._errordef = 0.5
super().__init__(
model=model, data=data, constraints=constraints, options=options
)
@z.function(wraps="loss")
def _loss_func(
self,
model: Iterable[ZfitBinnedPDF],
data: Iterable[ZfitBinnedData],
fit_range,
constraints,
log_offset,
):
poisson_terms = []
for mod, dat in zip(model, data):
values = dat.values( # TODO: right order of model and data?
# obs=mod.obs
)
variances = dat.variances()
probs = mod.counts(dat)
poisson_term = poisson_loss_calc(probs, values, log_offset, variances)
poisson_term_summed = znp.sum(poisson_term)
poisson_terms.append(poisson_term_summed) # TODO: change None
nll = znp.sum(poisson_terms)
if constraints:
constraints = z.reduce_sum([c.value() for c in constraints])
nll += constraints
return nll
@property
def is_extended(self):
return True
def _get_params(
self,
floating: bool | None = True,
is_yield: bool | None = None,
extract_independent: bool | None = True,
) -> set[ZfitParameter]:
return super()._get_params(floating, is_yield, extract_independent)
[docs]class BinnedNLL(BaseBinned):
def __init__(
self,
model: ztyping.BinnedPDFInputType,
data: ztyping.BinnedDataInputType,
constraints: ConstraintsInputType = None,
options: OptionsInputType = None,
):
r"""Binned negative log likelihood.
|@doc:loss.init.explain.spdtransform| A scaled Poisson distribution is
used as described by Bohm and Zech, NIMA 748 (2014) 1-6 |@docend:loss.init.explain.spdtransform|
The binned likelihood is the binned version of :py:class:`~zfit.loss.UnbinnedNLL`. It is defined as
.. math::
\\mathcal{L} = \\product \\mathcal{poiss}(N_{modelbin_i}, N_{databin_i}) = N_{databin_i}^{N_{modelbin_i}} \frac{e^{- N_{databin_i}}}{N_{modelbin_i}!}
where :math:`databin_i` is the :math:`i^{th}` bin in the data and
:math:`modelbin_i` is the :math:`i^{th}` bin of the model multiplied by the total number of events in data.
|@doc:loss.init.explain.simultaneous| A simultaneous fit can be performed by giving one or more `model`, `data`, to the loss. The
length of each has to match the length of the others
.. math::
\mathcal{L}_{simultaneous}(\theta | {data_0, data_1, ..., data_n})
= \prod_{i} \mathcal{L}(\theta_i, data_i)
where :math:`\theta_i` is a set of parameters and
a subset of :math:`\theta` |@docend:loss.init.explain.simultaneous|
|@doc:loss.init.explain.negativelog| For optimization purposes, it is often easier
to minimize a function and to use a log transformation. The actual loss is given by
.. math::
\mathcal{L} = - \sum_{i}^{n} ln(f(\theta|x_i))
and therefore being called "negative log ..." |@docend:loss.init.explain.negativelog|
Args:
model: |@doc:loss.binned.init.model| Binned PDF(s) that return the normalized probability
(`rel_counts` or `counts`) for
*data* under the given parameters.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.model|
data: |@doc:loss.binned.init.data| Binned dataset that will be given to the *model*.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.data|
constraints: |@doc:loss.init.constraints| Auxiliary measurements ("constraints")
that add a likelihood term to the loss.
.. math::
\mathcal{L}(\theta) = \mathcal{L}_{unconstrained} \prod_{i} f_{constr_i}(\theta)
Usually, an auxiliary measurement -- by its very nature -S should only be added once
to the loss. zfit does not automatically deduplicate constraints if they are given
multiple times, leaving the freedom for arbitrary constructs.
Constraints can also be used to restrict the loss by adding any kinds of penalties. |@docend:loss.init.constraints|
options: |@doc:loss.init.options| Additional options (as a dict) for the loss.
Current possibilities include:
- 'subtr_const' (default True): subtract from each points
log probability density a constant that
is approximately equal to the average log probability
density in the very first evaluation before
the summation. This brings the initial loss value closer to 0 and increases,
especially for large datasets, the numerical stability.
The value will be stored ith 'subtr_const_value' and can also be given
directly.
The subtraction should not affect the minimum as the absolute
value of the NLL is meaningless. However,
with this switch on, one cannot directly compare
different likelihoods ablolute value as the constant
may differ! Use `create_new` in order to have a comparable likelihood
between different losses
These settings may extend over time. In order to make sure that a loss is the
same under the same data, make sure to use `create_new` instead of instantiating
a new loss as the former will automatically overtake any relevant constants
and behavior. |@docend:loss.init.options|
"""
self._errordef = 0.5
super().__init__(
model=model, data=data, constraints=constraints, options=options
)
extended_pdfs = [pdf for pdf in self.model if pdf.is_extended]
if extended_pdfs and type(self) == BinnedNLL:
warn_advanced_feature(
f"Extended PDFs ({extended_pdfs}) are given to a normal BinnedNLL. "
f" This won't take the yield "
"into account and simply treat the PDFs as non-extended PDFs. To create an "
"extended NLL, use the `ExtendedBinnedNLL`.",
identifier="extended_in_BinnedNLL",
)
@z.function(wraps="loss")
def _loss_func(
self,
model: Iterable[ZfitBinnedPDF],
data: Iterable[ZfitBinnedData],
fit_range,
constraints,
log_offset,
):
poisson_terms = []
for mod, dat in zip(model, data):
values = dat.values( # TODO: right order of model and data?
# obs=mod.obs
)
variances = dat.variances()
probs = mod.rel_counts(dat)
probs *= znp.sum(values)
poisson_term = poisson_loss_calc(probs, values, log_offset, variances)
poisson_term_summed = znp.sum(poisson_term)
poisson_terms.append(poisson_term_summed)
nll = znp.sum(poisson_terms)
if constraints:
constraints = z.reduce_sum([c.value() for c in constraints])
nll += constraints
return nll
@property
def is_extended(self):
return False
def _get_params(
self,
floating: bool | None = True,
is_yield: bool | None = None,
extract_independent: bool | None = True,
) -> set[ZfitParameter]:
if not self.is_extended:
is_yield = False # the loss does not depend on the yields
return super()._get_params(floating, is_yield, extract_independent)
@z.function(wraps="tensor")
def chi2_loss_calc(probs, values, variances, log_offset=None, ignore_empty=None):
if ignore_empty is None:
ignore_empty = True
chi2_term = tf.math.squared_difference(probs, values)
if ignore_empty:
one_over_var = tf.math.reciprocal_no_nan(variances)
else:
one_over_var = tf.math.reciprocal(variances)
chi2_term *= one_over_var
chi2_term = znp.sum(chi2_term)
if log_offset is not None:
chi2_term += log_offset
return chi2_term
def _check_small_counts_chi2(data, ignore_empty):
for dat in data:
variances = dat.variances()
smaller_than_six = dat.values() < 6
if variances is None:
raise ValueError(f"variances cannot be None for Chi2: {dat}")
elif np.any(variances <= 0) and not ignore_empty:
raise ValueError(
f"Variances of {dat} contains zeros or negative numbers, cannot calculate chi2."
f" {variances}"
)
elif np.any(smaller_than_six):
warn_advanced_feature(
f"Some values in {dat} are < 6, the chi2 assumption of gaussian distributed"
f" uncertainties most likely won't hold anymore. Use Chi2 for large samples."
f"For smaller samples, consider using (Extended)BinnedNLL (or an unbinned fit).",
identifier="chi2_counts_small",
)
[docs]class BinnedChi2(BaseBinned):
def __init__(
self,
model: ztyping.BinnedPDFInputType,
data: ztyping.BinnedDataInputType,
constraints: ConstraintsInputType = None,
options: OptionsInputType = None,
):
r"""Binned Chi2 loss, using the :math:`N_{tot} from the data.
.. math::
\chi^2 = \sum_{\mathrm{bins}} \left( \frac{N_\mathrm{PDF,bin} - N_\mathrm{Data,bin}}{\sigma_\mathrm{Data,bin}} \right)^2
where
.. math::
N_\mathrm{PDF,bin} = \mathrm{pdf}(\text{integral}) \cdot N_\mathrm{Data,tot}
\sigma_\mathrm{bin} = \text{variance}
with `variance` the value of :class:`~zfit.data.BinnedData.variances` of the binned data.
|@doc:loss.init.binned.explain.chi2zeros| If the dataset has empty bins, the errors
will be zero and :math:`\chi^2` is undefined. Two possibilities are available and
can be given as an option:
- "empty": "ignore" will ignore all bins with zero entries and won't count to the loss
- "errors": "expected" will use the expected counts from the model
with a Poissonian uncertainty |@docend:loss.init.binned.explain.chi2zeros|
Args:
model: |@doc:loss.binned.init.model| Binned PDF(s) that return the normalized probability
(`rel_counts` or `counts`) for
*data* under the given parameters.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.model|
data: |@doc:loss.binned.init.data| Binned dataset that will be given to the *model*.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.data|
constraints: |@doc:loss.init.constraints| Auxiliary measurements ("constraints")
that add a likelihood term to the loss.
.. math::
\mathcal{L}(\theta) = \mathcal{L}_{unconstrained} \prod_{i} f_{constr_i}(\theta)
Usually, an auxiliary measurement -- by its very nature -S should only be added once
to the loss. zfit does not automatically deduplicate constraints if they are given
multiple times, leaving the freedom for arbitrary constructs.
Constraints can also be used to restrict the loss by adding any kinds of penalties. |@docend:loss.init.constraints|
options: |@doc:loss.init.options| Additional options (as a dict) for the loss.
Current possibilities include:
- 'subtr_const' (default True): subtract from each points
log probability density a constant that
is approximately equal to the average log probability
density in the very first evaluation before
the summation. This brings the initial loss value closer to 0 and increases,
especially for large datasets, the numerical stability.
The value will be stored ith 'subtr_const_value' and can also be given
directly.
The subtraction should not affect the minimum as the absolute
value of the NLL is meaningless. However,
with this switch on, one cannot directly compare
different likelihoods ablolute value as the constant
may differ! Use `create_new` in order to have a comparable likelihood
between different losses
These settings may extend over time. In order to make sure that a loss is the
same under the same data, make sure to use `create_new` instead of instantiating
a new loss as the former will automatically overtake any relevant constants
and behavior. |@docend:loss.init.options|
"""
self._errordef = 1.0
if options is None:
options = {}
if options.get("empty") is None:
options["empty"] = "ignore"
if options.get("errors") is None:
options["errors"] = "data"
super().__init__(
model=model, data=data, constraints=constraints, options=options
)
extended_pdfs = [pdf for pdf in self.model if pdf.is_extended]
if extended_pdfs and type(self) == BinnedChi2:
warn_advanced_feature(
f"Extended PDFs ({extended_pdfs}) are given to a normal BinnedChi2. "
f" This won't take the yield "
"into account and simply treat the PDFs as non-extended PDFs. To create an "
"extended loss, use the `ExtendedBinnedChi2`.",
identifier="extended_in_BinnedChi2",
)
def _precompile(self):
super()._precompile()
ignore_empty = (
self._options.get("empty") == "ignore"
or self._options.get("errors") == "expected"
)
data = self.data
_check_small_counts_chi2(data, ignore_empty)
@z.function(wraps="loss")
def _loss_func(
self,
model: Iterable[ZfitBinnedPDF],
data: Iterable[ZfitBinnedData],
fit_range,
constraints,
log_offset,
):
del fit_range
ignore_empty = self._options.get("empty") == "ignore"
chi2_terms = []
for mod, dat in zip(model, data):
values = dat.values( # TODO: right order of model and data?
# obs=mod.obs
)
probs = mod.rel_counts(dat)
probs *= znp.sum(values)
variance_method = self._options.get("errors")
if variance_method == "expected":
variances = znp.sqrt(probs + znp.asarray(1e-307, dtype=znp.float64))
elif variance_method == "data":
variances = dat.variances()
else:
raise ValueError()
if variances is None:
raise ValueError(f"variances cannot be None for Chi2: {dat}")
chi2_term = chi2_loss_calc(
probs, values, variances, log_offset, ignore_empty=ignore_empty
)
chi2_terms.append(chi2_term)
chi2_term = znp.sum(chi2_terms)
if constraints:
constraints = z.reduce_sum([c.value() for c in constraints])
chi2_term += constraints
return chi2_term
@property
def is_extended(self):
return False
def _get_params(
self,
floating: bool | None = True,
is_yield: bool | None = None,
extract_independent: bool | None = True,
) -> set[ZfitParameter]:
if not self.is_extended:
is_yield = False # the loss does not depend on the yields
return super()._get_params(floating, is_yield, extract_independent)
[docs]class ExtendedBinnedChi2(BaseBinned):
def __init__(
self,
model: ztyping.BinnedPDFInputType,
data: ztyping.BinnedDataInputType,
constraints: ConstraintsInputType = None,
options: OptionsInputType = None,
):
r"""Binned Chi2 loss, using the :math:`N_{tot} from the PDF.
.. math::
\chi^2 = \sum_{\mathrm{bins}} \left( \frac{N_\mathrm{PDF,bin} - N_\mathrm{Data,bin}}{\sigma_\mathrm{Data,bin}} \right)^2
where
.. math::
N_\mathrm{PDF,bin} = \mathrm{pdf}(\text{integral}) \cdot N_\mathrm{PDF,expected}
\sigma_\mathrm{bin} = \text{variance}
with `variance` the value of :class:`~zfit.data.BinnedData.variances` of the binned data.
|@doc:loss.init.binned.explain.chi2zeros| If the dataset has empty bins, the errors
will be zero and :math:`\chi^2` is undefined. Two possibilities are available and
can be given as an option:
- "empty": "ignore" will ignore all bins with zero entries and won't count to the loss
- "errors": "expected" will use the expected counts from the model
with a Poissonian uncertainty |@docend:loss.init.binned.explain.chi2zeros|
Args:
model: |@doc:loss.binned.init.model| Binned PDF(s) that return the normalized probability
(`rel_counts` or `counts`) for
*data* under the given parameters.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.model|
data: |@doc:loss.binned.init.data| Binned dataset that will be given to the *model*.
If multiple model and data are given, they will be used
in the same order to do a simultaneous fit. |@docend:loss.binned.init.data|
constraints: |@doc:loss.init.constraints| Auxiliary measurements ("constraints")
that add a likelihood term to the loss.
.. math::
\mathcal{L}(\theta) = \mathcal{L}_{unconstrained} \prod_{i} f_{constr_i}(\theta)
Usually, an auxiliary measurement -- by its very nature -S should only be added once
to the loss. zfit does not automatically deduplicate constraints if they are given
multiple times, leaving the freedom for arbitrary constructs.
Constraints can also be used to restrict the loss by adding any kinds of penalties. |@docend:loss.init.constraints|
options: |@doc:loss.init.options| Additional options (as a dict) for the loss.
Current possibilities include:
- 'subtr_const' (default True): subtract from each points
log probability density a constant that
is approximately equal to the average log probability
density in the very first evaluation before
the summation. This brings the initial loss value closer to 0 and increases,
especially for large datasets, the numerical stability.
The value will be stored ith 'subtr_const_value' and can also be given
directly.
The subtraction should not affect the minimum as the absolute
value of the NLL is meaningless. However,
with this switch on, one cannot directly compare
different likelihoods ablolute value as the constant
may differ! Use `create_new` in order to have a comparable likelihood
between different losses
These settings may extend over time. In order to make sure that a loss is the
same under the same data, make sure to use `create_new` instead of instantiating
a new loss as the former will automatically overtake any relevant constants
and behavior. |@docend:loss.init.options|
"""
self._errordef = 1.0
if options is None:
options = {}
if options.get("empty") is None:
options["empty"] = "ignore"
if options.get("errors") is None:
options["errors"] = "data"
super().__init__(
model=model, data=data, constraints=constraints, options=options
)
def _precompile(self):
super()._precompile()
ignore_empty = (
self._options.get("empty") == "ignore"
or self._options.get("errors") == "expected"
)
data = self.data
_check_small_counts_chi2(data, ignore_empty)
@z.function(wraps="loss")
def _loss_func(
self,
model: Iterable[ZfitBinnedPDF],
data: Iterable[ZfitBinnedData],
fit_range,
constraints,
log_offset,
):
del fit_range
ignore_empty = self._options.get("empty") == "ignore"
chi2_terms = []
for mod, dat in zip(model, data):
values = dat.values( # TODO: right order of model and data?
# obs=mod.obs
)
probs = mod.counts(dat)
variance_method = self._options.get("errors")
if variance_method == "expected":
variances = znp.sqrt(probs + znp.asarray(1e-307, dtype=znp.float64))
elif variance_method == "data":
variances = dat.variances()
else:
raise ValueError(f"Variance method {variance_method} not supported")
if variances is None:
raise ValueError(f"variances cannot be None for Chi2: {dat}")
chi2_term = chi2_loss_calc(
probs, values, variances, log_offset, ignore_empty=ignore_empty
)
chi2_terms.append(chi2_term)
chi2_term = znp.sum(chi2_terms)
if constraints:
constraints = z.reduce_sum([c.value() for c in constraints])
chi2_term += constraints
return chi2_term
@property
def is_extended(self):
return True
```