Esempio n. 1
0
    def __init__(
        self,
        xs,
        densities,
        scale: Scale,
        normalized=False,
        traceable=False,
        cumulative_normed_ps=None,
    ):
        if scale is None:
            raise ValueError

        self.scale = scale

        if normalized:
            self.normed_xs = xs
            self.normed_densities = densities

        else:
            self.normed_xs = scale.normalize_points(xs)
            self.normed_densities = scale.normalize_densities(
                self.normed_xs, densities)

        self.cumulative_normed_ps = cumulative_normed_ps
        if cumulative_normed_ps is None:
            self.cumulative_normed_ps = np.append(np.array([0]),
                                                  np.cumsum(self.bin_probs))
Esempio n. 2
0
    def from_pairs(cls,
                   pairs,
                   scale: Scale,
                   normalized=False,
                   interpolate=True):
        sorted_pairs = sorted([(v["x"], v["density"]) for v in pairs])
        xs = np.array([x for (x, density) in sorted_pairs])
        densities = np.array([density for (x, density) in sorted_pairs])

        if not normalized:
            xs = scale.normalize_points(xs)
            densities = scale.normalize_densities(xs, densities)

        if interpolate:
            # interpolate ps at target_xs
            if not (len(xs) == len(constants.target_xs)
                    and np.isclose(xs, constants.target_xs, rtol=1e-04).all()):
                f = interp1d(xs, densities)
                densities = f(constants.target_xs)

        # Make sure AUC is 1
        auc = np.sum(densities) / densities.size
        densities /= auc

        return cls(constants.target_xs,
                   densities,
                   scale=scale,
                   normalized=True)
Esempio n. 3
0
def test_density_norm_denorm_roundtrip(scale: Scale):
    rv = scipy.stats.logistic(loc=0.5, scale=0.15)
    normed_xs = np.linspace(0.01, 1, 201)
    normed_densities_truth_set = rv.pdf(normed_xs)
    xs = scale.denormalize_points(normed_xs)

    denormed_densities = scale.denormalize_densities(
        xs, normed_densities_truth_set)
    normed_densities = scale.normalize_densities(normed_xs, denormed_densities)

    assert np.allclose(normed_densities_truth_set,
                       normed_densities)  # type: ignore
Esempio n. 4
0
 def normalize(self, scale: Scale):
     normed_xs = scale.normalize_points(self.xs)
     normed_densities = scale.normalize_densities(normed_xs, self.densities)
     return self.__class__(normed_xs, normed_densities, self.weight)