def get_transforms(cache_size):
transforms = [
AbsTransform(cache_size=cache_size),
ExpTransform(cache_size=cache_size),
PowerTransform(exponent=2,
cache_size=cache_size),
PowerTransform(exponent=torch.tensor(5.).normal_(),
cache_size=cache_size),
PowerTransform(exponent=torch.tensor(5.).normal_(),
cache_size=cache_size),
SigmoidTransform(cache_size=cache_size),
TanhTransform(cache_size=cache_size),
AffineTransform(0, 1, cache_size=cache_size),
AffineTransform(1, -2, cache_size=cache_size),
AffineTransform(torch.randn(5),
torch.randn(5),
cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
SoftmaxTransform(cache_size=cache_size),
SoftplusTransform(cache_size=cache_size),
StickBreakingTransform(cache_size=cache_size),
LowerCholeskyTransform(cache_size=cache_size),
CorrCholeskyTransform(cache_size=cache_size),
ComposeTransform([
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
]),
ComposeTransform([
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
ExpTransform(cache_size=cache_size),
]),
ComposeTransform([
AffineTransform(0, 1, cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
AffineTransform(1, -2, cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
]),
ReshapeTransform((4, 5), (2, 5, 2)),
IndependentTransform(
AffineTransform(torch.randn(5),
torch.randn(5),
cache_size=cache_size),
1),
CumulativeDistributionTransform(Normal(0, 1)),
]
transforms += [t.inv for t in transforms]
return transforms
def __init__(self, loc, scale, validate_args=None):
self.loc, self.scale = broadcast_all(loc, scale)
finfo = _finfo(self.loc)
if isinstance(loc, Number) and isinstance(scale, Number):
base_dist = Uniform(finfo.tiny, 1 - finfo.eps)
else:
base_dist = Uniform(self.loc.new(self.loc.size()).fill_(finfo.tiny), 1 - finfo.eps)
transforms = [ExpTransform().inv, AffineTransform(loc=0, scale=-torch.ones_like(self.scale)),
ExpTransform().inv, AffineTransform(loc=loc, scale=-self.scale)]
super(Gumbel, self).__init__(base_dist, transforms, validate_args=validate_args)
def __init__(self, scale, alpha, validate_args=None):
self.scale, self.alpha = broadcast_all(scale, alpha)
base_dist = Exponential(self.alpha, validate_args=validate_args)
transforms = [ExpTransform(), AffineTransform(loc=0, scale=self.scale)]
super(Pareto, self).__init__(base_dist,
transforms,
validate_args=validate_args)
def get_transforms(cache_size):
transforms = [
AbsTransform(cache_size=cache_size),
ExpTransform(cache_size=cache_size),
PowerTransform(exponent=2,
cache_size=cache_size),
PowerTransform(exponent=torch.tensor(5.).normal_(),
cache_size=cache_size),
SigmoidTransform(cache_size=cache_size),
TanhTransform(cache_size=cache_size),
AffineTransform(0, 1, cache_size=cache_size),
AffineTransform(1, -2, cache_size=cache_size),
AffineTransform(torch.randn(5),
torch.randn(5),
cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
SoftmaxTransform(cache_size=cache_size),
StickBreakingTransform(cache_size=cache_size),
LowerCholeskyTransform(cache_size=cache_size),
CorrCholeskyTransform(cache_size=cache_size),
ComposeTransform([
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
]),
ComposeTransform([
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
ExpTransform(cache_size=cache_size),
]),
ComposeTransform([
AffineTransform(0, 1, cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
AffineTransform(1, -2, cache_size=cache_size),
AffineTransform(torch.randn(4, 5),
torch.randn(4, 5),
cache_size=cache_size),
]),
]
transforms += [t.inv for t in transforms]
return transforms
def __init__(self,
dim,
act=nn.ReLU(),
num_hiddens=[50],
nout=1,
conf=dict()):
nn.Module.__init__(self)
BNN.__init__(self)
self.dim = dim
self.act = act
self.num_hiddens = num_hiddens
self.nout = nout
self.steps_burnin = conf.get('steps_burnin', 2500)
self.steps = conf.get('steps', 2500)
self.keep_every = conf.get('keep_every', 50)
self.batch_size = conf.get('batch_size', 32)
self.warm_start = conf.get('warm_start', False)
self.lr_weight = np.float32(conf.get('lr_weight', 1e-3))
self.lr_noise = np.float32(conf.get('lr_noise', 1e-3))
self.lr_lambda = np.float32(conf.get('lr_lambda', 1e-3))
self.alpha_w = torch.as_tensor(1. * conf.get('alpha_w', 6.))
self.beta_w = torch.as_tensor(1. * conf.get('beta_w', 6.))
self.alpha_n = torch.as_tensor(1. * conf.get('alpha_n', 6.))
self.beta_n = torch.as_tensor(1. * conf.get('beta_n', 6.))
self.noise_level = conf.get('noise_level', None)
if self.noise_level is not None:
prec = 1 / self.noise_level**2
prec_var = (prec * 0.25)**2
self.beta_n = torch.as_tensor(prec / prec_var)
self.alpha_n = torch.as_tensor(prec * self.beta_n)
print("Reset alpha_n = %g, beta_n = %g" %
(self.alpha_n, self.beta_n))
self.prior_log_lambda = TransformedDistribution(
Gamma(self.alpha_w, self.beta_w),
ExpTransform().inv) # log of gamma distribution
self.prior_log_precision = TransformedDistribution(
Gamma(self.alpha_n, self.beta_n),
ExpTransform().inv)
self.log_lambda = nn.Parameter(torch.tensor(0.))
self.log_precs = nn.Parameter(torch.zeros(self.nout))
self.nn = NN(dim, self.act, self.num_hiddens, self.nout)
self.init_nn()
def expand(self, batch_shape, _instance=None):
new = self._get_checked_instance(RelaxedOneHotCategorical, _instance)
base_dist = self.base_dist.expand(batch_shape)
super(RelaxedOneHotCategorical, new).__init__(base_dist,
ExpTransform(),
validate_args=False)
new._validate_args = self._validate_args
return new
def __init__(self,
temperature,
probs=None,
logits=None,
validate_args=None):
super(RelaxedOneHotCategorical,
self).__init__(ExpRelaxedCategorical(temperature, probs, logits),
ExpTransform(),
validate_args=validate_args)
def expand(self, batch_shape, _instance=None):
new = self._get_checked_instance(LogNormal, _instance)
batch_shape = torch.Size(batch_shape)
base_dist = self.base_dist.expand(batch_shape)
super(LogNormal, new).__init__(base_dist,
ExpTransform(),
validate_args=False)
new._validate_args = self._validate_args
return new
def test_compose_transform_shapes():
transform0 = ExpTransform()
transform1 = SoftmaxTransform()
transform2 = LowerCholeskyTransform()
assert transform0.event_dim == 0
assert transform1.event_dim == 1
assert transform2.event_dim == 2
assert ComposeTransform([transform0, transform1]).event_dim == 1
assert ComposeTransform([transform0, transform2]).event_dim == 2
assert ComposeTransform([transform1, transform2]).event_dim == 2
def _embed_posterior(self, x, epsilon):
for xi in x:
if xi not in self.loc:
# Randomly initialize to break symmetry and prevent posteriors from
# starting in the same spot
self._loc[xi] = torch.nn.Parameter({
"random": torch.randn,
"prior": torch.zeros
}[self.unseen_policy](self.d_out))
self._scale[xi] = Param({
"random": lambda s: 0.1 * torch.ones(s),
"prior": torch.ones
}[self.unseen_policy](self.d_out),
transform=ExpTransform())
# NB "epsilon" takes care of whether self.random or not.
return torch.stack([
self.loc[xi] + self.scale[xi].transform() * epsilon[xi] for xi in x
])
def __init__(self,
dim,
act=nn.ReLU(),
num_hiddens=[50],
nout=1,
conf=dict()):
nn.Module.__init__(self)
BNN.__init__(self)
self.dim = dim
self.act = act
self.num_hiddens = num_hiddens
self.nout = nout
self.steps_burnin = conf.get('steps_burnin', 2500)
self.steps = conf.get('steps', 2500)
self.keep_every = conf.get('keep_every', 50)
self.batch_size = conf.get('batch_size', 32)
self.warm_start = conf.get('warm_start', False)
self.lr_weight = conf.get('lr_weight', 2e-2)
self.lr_noise = conf.get('lr_noise', 1e-1)
self.alpha_n = torch.as_tensor(1. * conf.get('alpha_n', 1e-2))
self.beta_n = torch.as_tensor(1. * conf.get('beta_n', 1e-1))
# user can specify a suggested noise value, this will override alpha_n and beta_n
self.noise_level = conf.get('noise_level', None)
if self.noise_level is not None:
prec = 1 / self.noise_level**2
prec_var = (prec * 0.25)**2
self.beta_n = torch.as_tensor(prec / prec_var)
self.alpha_n = torch.as_tensor(prec * self.beta_n)
print("Reset alpha_n = %g, beta_n = %g" %
(self.alpha_n, self.beta_n))
self.prior_log_precision = TransformedDistribution(
Gamma(self.alpha_n, self.beta_n),
ExpTransform().inv)
self.log_precs = nn.Parameter(torch.zeros(self.nout))
self.nn = NN(dim, self.act, self.num_hiddens, self.nout)
self.gain = 5. / 3 # Assume tanh activation
self.init_nn()
def __init__(self, log10_low, log10_high):
base_dist = torch.distributions.Uniform(
np.log(10) * log10_low,
np.log(10) * log10_high)
super(LogUniform, self).__init__(base_dist, [ExpTransform()])
def __init__(self, loc, scale):
super(LogNormal, self).__init__(Normal(loc, scale), ExpTransform())
def __init__(self, loc, scale, validate_args=None):
super(LogNormal, self).__init__(Normal(loc, scale), ExpTransform(), validate_args=validate_args)
def __init__(self, loc, scale, censMsk, validate_args=None):
super(LogNormalCens, self).__init__(NormalCens(loc, scale, censMsk), ExpTransform(), validate_args=validate_args)
def __init__(self, loc, scale, validate_args=None):
base_dist = Normal(loc, scale, validate_args=validate_args)
super(LogNormal, self).__init__(base_dist,
ExpTransform(),
validate_args=validate_args)
def _transform_to_positive_ordered_vector(constraint):
return ComposeTransform([OrderedTransform(), ExpTransform()])
def test_compose_transform_shapes():
transform0 = ExpTransform()
transform1 = SoftmaxTransform()
transform2 = LowerCholeskyTransform()
assert transform0.event_dim == 0
assert transform1.event_dim == 1
assert transform2.event_dim == 2
assert ComposeTransform([transform0, transform1]).event_dim == 1
assert ComposeTransform([transform0, transform2]).event_dim == 2
assert ComposeTransform([transform1, transform2]).event_dim == 2
transform0 = ExpTransform()
transform1 = SoftmaxTransform()
transform2 = LowerCholeskyTransform()
base_dist0 = Normal(torch.zeros(4, 4), torch.ones(4, 4))
base_dist1 = Dirichlet(torch.ones(4, 4))
base_dist2 = Normal(torch.zeros(3, 4, 4), torch.ones(3, 4, 4))
@pytest.mark.parametrize('batch_shape, event_shape, dist', [
((4, 4), (), base_dist0),
((4,), (4,), base_dist1),
((4, 4), (), TransformedDistribution(base_dist0, [transform0])),
((4,), (4,), TransformedDistribution(base_dist0, [transform1])),
((4,), (4,), TransformedDistribution(base_dist0, [transform0, transform1])),
((), (4, 4), TransformedDistribution(base_dist0, [transform0, transform2])),
((4,), (4,), TransformedDistribution(base_dist0, [transform1, transform0])),
class TransformMixIn:
"""Mixin for providing pre- and post-processing capabilities to encoders.
Class should have a ``transformation`` attribute to indicate how to preprocess data.
"""
# dict of PyTorch functions that transforms and inversely transforms values.
# inverse entry required if "reverse" is not the "inverse" of "forward".
TRANSFORMATIONS = {
"log":
dict(forward=_clipped_log,
reverse=torch.exp,
inverse_torch=ExpTransform()),
"log1p":
dict(forward=torch.log1p,
reverse=torch.exp,
inverse=torch.expm1,
inverse_torch=Expm1Transform()),
"logit":
dict(forward=_clipped_logit,
reverse=_clipped_sigmoid,
inverse_torch=SigmoidTransform()),
"count":
dict(forward=_plus_one,
reverse=F.softplus,
inverse=_minus_one,
inverse_torch=MinusOneTransform()),
"softplus":
dict(forward=softplus_inv,
reverse=F.softplus,
inverse_torch=SoftplusTransform()),
"relu":
dict(forward=_identity,
reverse=F.relu,
inverse=_identity,
inverse_torch=ReLuTransform()),
"sqrt":
dict(forward=torch.sqrt,
reverse=_square,
inverse_torch=PowerTransform(exponent=2.0)),
}
@classmethod
def get_transform(
cls, transformation: Union[str,
Dict[str,
Callable]]) -> Dict[str, Callable]:
"""Return transformation functions.
Args:
transformation (Union[str, Dict[str, Callable]]): name of transformation or
dictionary with transformation information.
Returns:
Dict[str, Callable]: dictionary with transformation functions (forward, reverse, inverse and inverse_torch)
"""
return cls.TRANSFORMATIONS.get(transformation, transformation)
def preprocess(
self, y: Union[pd.Series, pd.DataFrame, np.ndarray, torch.Tensor]
) -> Union[np.ndarray, torch.Tensor]:
"""
Preprocess input data (e.g. take log).
Uses ``transform`` attribute to determine how to apply transform.
Returns:
Union[np.ndarray, torch.Tensor]: return rescaled series with type depending on input type
"""
if self.transformation is None:
return y
if isinstance(y, torch.Tensor):
y = self.get_transform(self.transformation)["forward"](y)
else:
# convert first to tensor, then transform and then convert to numpy array
if isinstance(y, (pd.Series, pd.DataFrame)):
y = y.to_numpy()
y = torch.as_tensor(y)
y = self.get_transform(self.transformation)["forward"](y)
y = np.asarray(y)
return y
def inverse_preprocess(
self, y: Union[pd.Series, np.ndarray, torch.Tensor]
) -> Union[np.ndarray, torch.Tensor]:
"""
Inverse preprocess re-scaled data (e.g. take exp).
Uses ``transform`` attribute to determine how to apply inverse transform.
Returns:
Union[np.ndarray, torch.Tensor]: return rescaled series with type depending on input type
"""
if self.transformation is None:
pass
elif isinstance(y, torch.Tensor):
y = self.get_transform(self.transformation)["reverse"](y)
else:
# convert first to tensor, then transform and then convert to numpy array
y = torch.as_tensor(y)
y = self.get_transform(self.transformation)["reverse"](y)
y = np.asarray(y)
return y