Add mechanism to register custom integrator for CDF approximation for extended likelihoods

[ikrommyd]

Currently, if you don't know the CDF analytically in an extended likelihood, you have the option to integrate within the bins via doing height * bin width or using numerical quadrature integration.
But what if you want something better than the rectangle appoximation. but something faster then quad?
You can hack your way around it and overwrite the ._pred_impl I think (from looking at the code) and so something like this

cost = ExtendedBinnedNLL(self._bin_values, self._bin_edges, model_pdf, use_pdf="approximate")

def _pred_simpson(args):
    from scipy.integrate import simpson

    d = np.empty(len(self._bin_edges) - 1)
    for i in range(len(self._bin_edges) - 1):
        a = self._bin_edges[i]
        b = self._bin_edges[i + 1]
        x_points = np.linspace(a, b, 11)
        y_points = model_pdf(x_points, *args)
        d[i] = simpson(y_points, x=x_points)
    return d

cost._pred_impl = _pred_simpson

to register a simpson integration for example. But it definitely is hacky.

It would be nice if there is an official mechanism to support registering such "integrators" and maybe even add something in the middle of numeric quadrature and rectangle approximation in the official code in terms of accuracy vs speed. Maybe trapezoid or simpson?

[HDembinski]

It is a good idea in principle to allow for customization. The rectangle approximation was chosen because it makes no assumptions on the continuity of the PDF. Simpson and others assume that the function has a certain degree of smoothness so that it can be approximated by a low-order polynomial. That's not the case for a PDF with discontinuities, for example, which do exist.

Can you suggest an interface for this? Perhaps we can allow a callable for use_pdf, which then replaces the internal integration logic. The integrator should expect to a callable (the PDF) and two points, which are the edges.

[ikrommyd]

Yeah I was thinking either a callable use_pdf or a registration mechanism like

cost.register_pdf_integrator(blah blah)

or something. Probably the callable is a simpler API.

And yeah you are right, the callable would just be an "integrator" in the sense that it takes a PDF and two edges and integrates it. I don't know whether its worth generalizing to more than 1 dimensions here. In my hacky snippet above I had to do the loop over bin edges internally but that's only because that's what _pred_impl expects.