def __init__(self, left, right, exclusion=None, repr_args=None):
if not isinstance(left, Distribution):
left = numpy.atleast_1d(left)
if left.ndim > 1:
raise chaospy.UnsupportedFeature(
"distribution operators limited to at-most 1D arrays.")
if not isinstance(right, Distribution):
right = numpy.atleast_1d(right)
if right.ndim > 1:
raise chaospy.UnsupportedFeature(
"distribution operators limited to at-most 1D arrays.")
dependencies, parameters, rotation = chaospy.declare_dependencies(
distribution=self,
parameters=dict(left=left, right=right),
is_operator=True,
)
super(OperatorDistribution, self).__init__(
parameters=parameters,
dependencies=dependencies,
exclusion=exclusion,
repr_args=repr_args,
)
self._cache_copy = {}
self._lower_cache = {}
self._upper_cache = {}
def __init__(self, df, covariance, rotation=None):
assert isinstance(df, float)
covariance = numpy.asarray(covariance)
assert covariance.ndim == 2, "Covariance must be a matrix"
assert covariance.shape[0] == covariance.shape[1], (
"Parameters 'covariance' not a square matrix.")
dependencies, _, rotation = chaospy.declare_dependencies(
self,
parameters=dict(covariance=covariance),
rotation=rotation,
dependency_type="accumulate",
)
correlation = covariance / numpy.sqrt(
numpy.outer(numpy.diag(covariance), numpy.diag(covariance)))
self._permute = numpy.eye(len(rotation), dtype=int)[rotation]
self._correlation = self._permute.dot(correlation).dot(self._permute.T)
cholesky = numpy.linalg.cholesky(self._correlation)
self._fwd_transform = self._permute.T.dot(numpy.linalg.inv(cholesky))
self._inv_transform = self._permute.T.dot(cholesky)
super(t_copula, self).__init__(
parameters=dict(df=df),
dependencies=dependencies,
rotation=rotation,
repr_args=[covariance.tolist()],
)
def __init__(
self,
mu,
sigma,
rotation=None,
):
repr_args = [mu, sigma]
dependencies, parameters, rotation = chaospy.declare_dependencies(
self,
parameters=dict(mu=mu, sigma=sigma),
rotation=rotation,
dependency_type="accumulate",
)
sigma = parameters["sigma"]
assert sigma.ndim == 2, "Covariance must either be scalar, vector or matrix"
self._permute = numpy.eye(len(rotation), dtype=int)[rotation]
self._psigma = self._permute.dot(sigma).dot(self._permute.T)
cholesky = numpy.linalg.cholesky(self._psigma)
self._fwd_transform = self._permute.T.dot(numpy.linalg.inv(cholesky))
self._inv_transform = self._permute.T.dot(cholesky)
super(MvLogNormal, self).__init__(
parameters=parameters,
dependencies=dependencies,
rotation=rotation,
repr_args=repr_args,
)
def __init__(
self,
dist,
shift=0,
scale=1,
rotation=None,
repr_args=None,
):
assert isinstance(dist,
Distribution), "'dist' should be a distribution"
if repr_args is None:
repr_args = dist._repr_args[:]
repr_args += chaospy.format_repr_kwargs(scale=(scale, 1))
repr_args += chaospy.format_repr_kwargs(shift=(shift, 0))
length = len(dist) if len(dist) > 1 else None
dependencies, parameters, rotation = chaospy.declare_dependencies(
distribution=self,
parameters=dict(shift=shift, scale=scale),
rotation=rotation,
is_operator=True,
length=length,
extra_parameters=dict(dist=dist),
)
super(ShiftScaleDistribution, self).__init__(
parameters=parameters,
rotation=rotation,
dependencies=dependencies,
repr_args=repr_args,
)
self._dist = dist
permute = numpy.zeros((len(self._rotation), len(self._rotation)),
dtype=int)
permute[numpy.arange(len(self._rotation), dtype=int),
self._rotation] = 1
self._permute = permute
def __init__(
self,
dist,
lower=0.0,
upper=1.0,
rotation=None,
repr_args=None,
):
assert isinstance(dist,
Distribution), "'dist' should be a distribution"
assert len(dist) == 1
if repr_args is None:
repr_args = dist._repr_args[:]
repr_args += chaospy.format_repr_kwargs(lower=(lower, 0),
upper=(upper, 1))
dependencies, parameters, rotation, = chaospy.declare_dependencies(
distribution=self,
parameters=dict(lower=lower, upper=upper),
is_operator=True,
rotation=rotation,
extra_parameters=dict(dist=dist),
)
assert len(dependencies) == 1
assert len(parameters["lower"]) == 1
assert len(parameters["upper"]) == 1
super(LowerUpperDistribution, self).__init__(
parameters=parameters,
dependencies=dependencies,
rotation=rotation,
repr_args=repr_args,
)
self._dist = dist
def __init__(
self,
dist,
lower=0.,
upper=1.,
rotation=None,
repr_args=None,
):
assert isinstance(dist,
Distribution), "'dist' should be a distribution"
if repr_args is None:
repr_args = dist._repr_args[:]
repr_args += chaospy.format_repr_kwargs(lower=(lower, 0),
upper=(upper, 1))
dependencies, parameters, rotation, = chaospy.declare_dependencies(
distribution=self,
parameters=dict(lower=lower, upper=upper),
rotation=rotation,
)
super(LowerUpperDistribution, self).__init__(
parameters=parameters,
dependencies=dependencies,
repr_args=repr_args,
)
self._dist = dist
def __init__(self, dist, lower=None, upper=None):
"""
Constructor.
Args:
dist (Distribution):
Distribution to be truncated.
lower (Distribution, numpy.ndarray):
Lower truncation bound.
upper (Distribution, numpy.ndarray):
Upper truncation bound.
"""
assert isinstance(dist, Distribution)
repr_args = [dist]
repr_args += chaospy.format_repr_kwargs(lower=(lower, None))
repr_args += chaospy.format_repr_kwargs(upper=(upper, None))
exclusion = set()
for deps in dist._dependencies:
exclusion.update(deps)
if isinstance(lower, Distribution):
if lower.stochastic_dependent:
raise chaospy.StochasticallyDependentError(
"Joint distribution with dependencies not supported."
)
assert len(dist) == len(lower)
lower_ = lower.lower
elif lower is None:
lower = lower_ = dist.lower
else:
lower = lower_ = numpy.atleast_1d(lower)
if isinstance(upper, Distribution):
if upper.stochastic_dependent:
raise chaospy.StochasticallyDependentError(
"Joint distribution with dependencies not supported."
)
assert len(dist) == len(upper)
upper_ = upper.upper
elif upper is None:
upper = upper_ = dist.upper
else:
upper = upper_ = numpy.atleast_1d(upper)
assert numpy.all(
upper_ > lower_
), "condition `upper > lower` not satisfied: %s <= %s" % (upper_, lower_)
dependencies, parameters, rotation = chaospy.declare_dependencies(
distribution=self,
parameters=dict(lower=lower, upper=upper),
length=len(dist),
)
super(Trunc, self).__init__(
parameters=parameters,
dependencies=dependencies,
exclusion=exclusion,
repr_args=repr_args,
)
self._dist = dist
def __init__(self, length, theta=1.0, rotation=None):
if rotation is not None:
assert length == len(rotation)
dependencies, _, rotation = chaospy.declare_dependencies(
self,
parameters=dict(theta=theta),
rotation=rotation,
dependency_type="accumulate",
length=length,
)
super(Archimedean, self).__init__(
parameters=dict(theta=float(theta)),
dependencies=dependencies,
rotation=rotation,
repr_args=[length, "theta=%s" % theta],
)
def __init__(
self,
parameters=None,
rotation=None,
exclusion=None,
repr_args=None,
):
"""
Args:
parameters (Optional[Distribution[str, Union[ndarray, Distribution]]]):
Collection of model parameters.
rotation (None, Sequence[int], Sequence[Sequence[bool]]):
The order of which to resolve conditionals. Either as
a sequence of column rotations, or as a permutation
matrix. Defaults to `range(len(distribution))` which
is the same as `p(x0), p(x1|x0), p(x2|x0,x1), ...`.
repr_args (Optional[Sequence[str]]):
Positional arguments to place in the object string
representation. The repr output will then be:
`<class name>(<arg1>, <arg2>, ...)`.
"""
if parameters is None:
parameters = {}
dependencies, parameters, rotation = chaospy.declare_dependencies(
distribution=self,
parameters=parameters,
rotation=rotation,
)
super(SimpleDistribution, self).__init__(
parameters=parameters,
dependencies=dependencies,
rotation=rotation,
exclusion=exclusion,
repr_args=repr_args,
)
def __init__(
self,
samples,
h_mat=None,
estimator_rule="scott",
weights=None,
rotation=None,
):
"""
Args:
samples (numpy.ndarray):
The samples to generate density estimation. Assumed to have
shape either as `(n_samples,)`, or `(n_dim, n_samples)`.
h_mat (Optional[numpy.ndarray]):
The H-matrix, also known as the smoothing matrix or bandwidth
matrix. In one dimension it correspond to the square of the
bandwidth parameters often used in the one-dimensional case.
Assumes shape either something compatible with
`(n_dim, n_dim)`, or `(n_dim, n_dim, n_samples)` in the case
where each sample have their own H-matrix. If omitted, it is
automatically calculated using `estimator_rule`.
estimator_rule (str):
Which method to use to select smoothing matrix from, assuming
it is omitted. Choose from 'scott' and 'silverman'.
weights (Optional[numpy.ndarray]):
Weights of the samples. This must have the shape
`(n_samples,)`. If omitted, each sample is assumed to be
equally weighted.
"""
samples = numpy.atleast_2d(samples)
assert samples.ndim == 2
# the scale is taken from Scott-92.
# The Scott factor is taken from scipy docs.
if h_mat is None:
if estimator_rule in ("scott", "silverman"):
qrange = numpy.quantile(samples, [0.25, 0.75],
axis=1).ptp(axis=0)
scale = numpy.min([numpy.std(samples, axis=1), qrange / 1.34],
axis=0)
factor = samples.shape[1]
if estimator_rule == "silverman":
factor *= (len(samples) + 2) / 4.0
factor **= -1.0 / (len(samples) + 4)
covariance = numpy.diag(scale * factor)**2
else:
raise ValueError("unknown estimator rule: %s" % estimator_rule)
else:
covariance = numpy.asfarray(h_mat)
if covariance.ndim in (0, 1):
covariance = covariance * numpy.eye(len(samples))
if covariance.ndim == 2:
covariance = covariance[numpy.newaxis]
else:
covariance = numpy.rollaxis(covariance, 2, 0)
assert covariance.shape[1:] == (len(samples), len(samples))
if weights is None:
weights = 1.0 / samples.shape[1]
self.weights = weights
dependencies, _, rotation = chaospy.declare_dependencies(
self,
dict(),
rotation=rotation,
dependency_type="accumulate",
length=len(samples),
)
self._samples = samples
self._covariance = covariance
self._permute = numpy.eye(len(rotation), dtype=int)[rotation]
self._pcovariance = numpy.matmul(
numpy.matmul(self._permute, covariance), self._permute.T)
cholesky = numpy.linalg.cholesky(self._pcovariance)
self._fwd_transform = numpy.linalg.inv(cholesky)
self._inv_transform = cholesky
super(KernelDensityBaseclass, self).__init__(
parameters={},
dependencies=dependencies,
rotation=rotation,
)
self._zloc = None
self._kernel0 = None
self._kernel1 = None
