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))
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)
def from_pairs(cls, pairs, scale: Scale, normalized=False):
sorted_pairs = sorted([(v["x"], v["density"]) for v in pairs])
xs = [x for (x, density) in sorted_pairs]
if not normalized:
xs = scale.normalize_points(xs)
densities = [density for (x, density) in sorted_pairs]
logps = onp.log(onp.array(densities))
return cls(logps, scale)
def from_samples(
cls: Type[T],
data,
fixed_params=None,
scale=None,
verbose=False,
init_tries=1,
opt_tries=1,
) -> T:
if fixed_params is None:
fixed_params = {}
data = np.array(data)
if scale is None:
data_range = max(data) - min(data)
scale = Scale(
low=min(data) - 0.25 * data_range,
high=max(data) + 0.25 * data_range,
)
fixed_params = cls.normalize_fixed_params(fixed_params, scale)
normalized_data = np.array(scale.normalize_points(data))
def loss(opt_params):
return static.dist_logloss(cls, fixed_params, opt_params,
normalized_data)
def jac(opt_params):
return static.dist_grad_logloss(cls, fixed_params, opt_params,
normalized_data)
normalized_dist = cls.from_loss(
loss,
jac,
fixed_params=fixed_params,
verbose=verbose,
init_tries=init_tries,
opt_tries=opt_tries,
)
return normalized_dist.denormalize(scale)
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)
