def __init__(self, shape, loc, scale, beta=0.5):
scale_prior = PositiveImproper(shape=[], loc=scale, scale=1.)
beta_prior = PositiveImproper(shape=[], loc=beta, scale=1.)
with torch.no_grad():
scale_prior.p.data = inv_softplus(torch.tensor(scale))
beta_prior.p.data = inv_softplus(torch.tensor(beta))
super().__init__(shape, loc, scale=scale_prior, beta=beta_prior)
def __init__(self, shape, loc, scale, df=2.):
scale_prior = PositiveImproper(shape=[], loc=scale, scale=1.)
df_prior = PositiveImproper(shape=[], loc=df, scale=1.)
with torch.no_grad():
scale_prior.p.data = inv_softplus(torch.tensor(scale))
df_prior.p.data = inv_softplus(torch.tensor(df))
super().__init__(shape, loc, scale=scale_prior, df=df_prior)
def StepTanhL(num_blocks, num_steps, **kwargs):
set_res, addf0, init_random, constraint = common_config(kwargs)
if 'set_res' in kwargs.keys():
assert kwargs[
'set_res'] == True, 'In the step tanh flow set_res has to be True for num_steps > 1'
set_res = True
input_dependent, input_dim, input_dependent_config = set_input_dependent_config(
kwargs)
block_array = []
for nb in range(num_blocks):
step_flow_arr = []
for st in range(
num_steps
): # each step in the linear combination should be initialized to different values otherwise gradients
# will always point in the same direction and the parameters will be equal after each gradient update.
# w = numpy.log(numpy.exp(1./float(num_steps))-1) # softmin
e1, e2, e3, e4 = numpy.multiply(numpy.random.randn(4, ),
numpy.array([1.0, 1.0, 1.0, 1.0]))
if not init_random:
e2 = inv_softplus(
torch.abs(torch.tensor(
(e2 + 1.0) / float(num_steps)))).item()
e4 = inv_softplus(
torch.abs(torch.tensor(
(e4 + 1.0) / float(num_steps)))).item()
init_tanh = {
'init_a': e1,
'init_b': e2,
'init_c': e3,
'init_d': e4,
'add_init_f0': False,
'set_restrictions': set_res,
'input_dependent': input_dependent,
'input_dim': input_dim,
'input_dependent_config': input_dependent_config
}
step_flow_arr.append(('tanh', init_tanh))
if init_random:
a_aff, b_aff = numpy.random.randn(2)
else:
a_aff, b_aff = 1.0, 0.0
init_affine = {
'init_a': a_aff,
'init_b': b_aff,
'set_restrictions': False
}
init_step_tanh = {'flow_arr': step_flow_arr, 'add_init_f0': addf0}
block = [('step_flow', init_step_tanh), ('affine', init_affine)]
block_array.extend(block)
return block_array
def __init__(self, shape, loc, scale, lengthscale=1.0):
lengthscale_prior = PositiveImproper(shape=[],
loc=lengthscale,
scale=1.)
scale_prior = PositiveImproper(shape=[], loc=scale, scale=1.)
with torch.no_grad():
lengthscale_prior.p.data = inv_softplus(torch.tensor(lengthscale))
scale_prior.p.data = inv_softplus(torch.tensor(scale))
super().__init__(shape,
loc,
scale=scale_prior,
lengthscale=lengthscale_prior)
def __init__(self, shape, loc, scale, lengthscale=1., rate=1.):
lengthscale_prior = Gamma(shape=[],
concentration=lengthscale,
rate=rate)
scale_prior = Gamma(shape=[], concentration=scale, rate=rate)
with torch.no_grad():
lengthscale_prior.p.data = inv_softplus(torch.tensor(lengthscale))
scale_prior.p.data = inv_softplus(torch.tensor(scale))
super().__init__(shape,
loc,
scale=scale_prior,
lengthscale=lengthscale_prior)
def __init__(self, shape, loc, scale, base_dist="gaussian", scales=None):
if scales is None:
self.scales = [scale / 9, scale / 3, scale, scale * 3, scale * 9]
else:
self.scales = scales
super().__init__(shape, loc, scale)
self.mixture_weights = torch.nn.Parameter(torch.zeros(len(
self.scales)))
scale_priors = [
PositiveImproper(shape=[], loc=scl, scale=1.)
for scl in self.scales
]
for scale_prior, scl in zip(scale_priors, self.scales):
with torch.no_grad():
scale_prior.p.data = inv_softplus(torch.tensor(scl))
self.components = [
get_prior(base_dist)(shape, loc, scl) for scl in scale_priors
]
for comp in self.components:
comp.p = self.p
comp._old_log_prob = comp.log_prob
# Prevent the sum over priors from double-counting this one
comp.log_prob = (lambda: 0.)
for i, comp in enumerate(self.components):
self.add_module(f"component_{i}", comp)
# Now that all parameters are initialized, sample properly
self.sample()
def __init__(self,is_trainable: bool, n_steps : int):
super(switch_off, self).__init__()
self.is_trainable = is_trainable
if self.is_trainable:
# the weight a is initialized to 1/number_steps so that if we perform a linear combination of lots of flows we do not easily saturate
a = torch.tensor(1.0/float(n_steps),dtype=cg.dtype)
a = inv_softplus(a) # as we apply the softplus we need to first compute the softminus so that at initialization the scale parameter a = 1/n_steps
self.a = nn.Parameter(a)
self.b = nn.Parameter(torch.tensor(0.0,dtype=cg.dtype))
def StepSAL(num_blocks, num_steps, **kwargs):
set_res, addf0, init_random, constraint = common_config(kwargs)
if 'set_res' in kwargs.keys():
assert kwargs[
'set_res'] == True, 'In the step sa flow set_res has to be True for num_steps > 1'
set_res = True
block_array = []
for nb in range(num_blocks):
step_flow_arr = []
for st in range(
num_steps
): # each step in the linear combination should be initialized to different values otherwise gradients
a_sal, b_sal = numpy.random.randn(2)
if not init_random:
b_sal += 1.0
b_sal = inv_softplus(torch.abs(torch.tensor(b_sal))).item()
init_sinh_arcsinh = {
'init_a': a_sal,
'init_b': b_sal,
'add_init_f0': False,
'set_restrictions': set_res
}
step_flow_arr.append(('sinh_arcsinh', init_sinh_arcsinh))
if init_random:
a_aff, b_aff = numpy.random.randn(2)
else:
a_aff, b_aff = 1.0, 0.0
init_affine = {
'init_a': a_aff,
'init_b': b_aff,
'set_restrictions': False
}
init_step_sa = {'flow_arr': step_flow_arr, 'add_init_f0': addf0}
block = [('step_flow', init_step_sa), ('affine', init_affine)]
block_array.extend(block)
return block_array
def __init__(self, shape, loc, scale, hyperscale=1., gradient_clip=1.):
scale_prior = HalfCauchy(shape=[], scale=hyperscale, multiplier=scale)
with torch.no_grad():
scale_prior.p.data = inv_softplus(torch.tensor(1.))
super().__init__(shape, loc, scale_prior)
def __init__(self, shape, loc, scale, rate=1., df=2, gradient_clip=1.):
scale_prior = Gamma(shape=[], concentration=scale, rate=rate)
with torch.no_grad():
scale_prior.p.data = inv_softplus(torch.tensor(scale))
super().__init__(shape, loc, scale_prior, df=df)
def _sample_value(self, shape: torch.Size):
x = super()._sample_value(shape)
return inv_softplus(x)
def StepAllL(num_blocks, **kwargs):
set_res, addf0, init_random, constraint = common_config(kwargs)
if 'set_res' in kwargs.keys():
assert kwargs[
'set_res'] == True, 'In the step tanh flow set_res has to be True for num_steps > 1'
set_res = True
num_steps = 5
block_array = []
for nb in range(num_blocks):
step_flow_arr = []
## Inverse Box Cox
init_lam = numpy.random.randn(1, )
if not init_random:
init_lam += 5.0
init_bc = {
'init_lam': init_lam,
'add_init_f0': addf0,
'constraint': constraint
}
step_flow_arr.append(('inverseboxcox', init_bc))
## Box Cox Flow
init_lam = numpy.random.randn(1, )
if not init_random:
init_lam += 5.0
init_bc = {
'init_lam': init_lam,
'add_init_f0': addf0,
'constraint': constraint
}
step_flow_arr.append(('boxcox', init_bc))
## Arcsinh Flow
e1, e2, e3, e4 = numpy.multiply(numpy.random.randn(4, ),
numpy.array([1.0, 1.0, 1.0, 1.0]))
if not init_random:
e2 = inv_softplus(
torch.abs(torch.tensor((e2 + 1.0) / float(num_steps)))).item()
e4 = inv_softplus(
torch.abs(torch.tensor((e4 + 1.0) / float(num_steps)))).item()
init_arcsinh = {
'init_a': e1,
'init_b': e2,
'init_c': e3,
'init_d': e4,
'add_init_f0': False,
'set_restrictions': set_res
}
step_flow_arr.append(('arcsinh', init_arcsinh))
## SAL Flow
a_sal, b_sal = numpy.random.randn(2)
if not init_random:
b_sal += 1.0
b_sal = inv_softplus(torch.abs(torch.tensor(b_sal))).item()
init_sinh_arcsinh = {
'init_a': a_sal,
'init_b': b_sal,
'add_init_f0': False,
'set_restrictions': set_res
}
step_flow_arr.append(('sinh_arcsinh', init_sinh_arcsinh))
## Tanh Flow
e1, e2, e3, e4 = numpy.multiply(numpy.random.randn(4, ),
numpy.array([1.0, 1.0, 1.0, 1.0]))
if not init_random:
e2 = inv_softplus(
torch.abs(torch.tensor((e2 + 1.0) / float(num_steps)))).item()
e4 = inv_softplus(
torch.abs(torch.tensor((e4 + 1.0) / float(num_steps)))).item()
init_tanh = {
'init_a': e1,
'init_b': e2,
'init_c': e3,
'init_d': e4,
'add_init_f0': False,
'set_restrictions': set_res
}
step_flow_arr.append(('tanh', init_tanh))
if init_random:
a_aff, b_aff = numpy.random.randn(2)
else:
a_aff, b_aff = 1.0, 0.0
init_affine = {
'init_a': a_aff,
'init_b': b_aff,
'set_restrictions': False
}
init_step = {'flow_arr': step_flow_arr, 'add_init_f0': addf0}
block = [('step_flow', init_step), ('affine', init_affine)]
block_array.extend(block)
return block_array
