def __init__(self,
a,
theta,
alpha,
beta,
validate_args=False,
allow_nan_stats=True,
name='Amoroso'):
parameters = dict(locals())
with tf.name_scope(name) as name:
self._a = tensor_util.convert_nonref_to_tensor(a)
self._theta = tensor_util.convert_nonref_to_tensor(theta)
self._alpha = tensor_util.convert_nonref_to_tensor(alpha)
self._beta = tensor_util.convert_nonref_to_tensor(beta)
gamma = tfd.Gamma(alpha, 1.)
chain = tfb.Invert(
tfb.Chain([
tfb.Exp(),
tfb.Scale(beta),
tfb.Shift(-tf.math.log(theta)),
tfb.Log(),
tfb.Shift(-a),
]))
super().__init__(distribution=gamma,
bijector=chain,
validate_args=validate_args,
parameters=parameters,
name=name)
def init_bijectors(self,
a1: tf.Tensor,
b1: tf.Tensor,
theta: tf.Tensor,
a2: tf.Tensor,
b2: tf.Tensor,
name: str = 'bernstein_flow') -> tfb.Bijector:
"""
Builds a normalizing flow using a Bernstein polynomial as Bijector.
:param a1: The scale of f1.
:type a1: Tensor
:param b1: The shift of f1.
:type b1: Tensor
:param theta: The Bernstein coefficients.
:type theta: Tensor
:param a2: The scale of f3.
:type a2: Tensor
:param b2: The shift of f3.
:type b2: Tensor
:param name: The name to give Ops created by the initializer.
:type name: string
:returns: The Bernstein flow.
:rtype: Bijector
"""
bijectors = []
# f1: ŷ = sigma(a1(x)*y - b1(x))
f1_scale = tfb.Scale(a1, name='f1_scale')
bijectors.append(f1_scale)
f1_shift = tfb.Shift(b1, name='f1_shift')
bijectors.append(f1_shift)
# clip to range [0, 1]
bijectors.append(tfb.SoftClip(low=0, high=1, hinge_softness=1.5))
# f2: ẑ = Bernstein Polynomial
f2 = BernsteinBijector(theta=theta, name='f2')
bijectors.append(f2)
# clip to range [min(theta), max(theta)]
# bijectors.append(
# tfb.Invert(
# tfb.SoftClip(
# high=tf.math.reduce_max(theta, axis=-1),
# low=tf.math.reduce_min(theta, axis=-1),
# hinge_softness=0.5
# )
# )
# )
# f3: z = a2(x)*ẑ - b2(x)
f3_scale = tfb.Scale(a2, name='f3_scale')
bijectors.append(f3_scale)
f3_shift = tfb.Shift(b2, name='f3_shift')
bijectors.append(f3_shift)
bijectors = list(reversed(bijectors))
return tfb.Invert(tfb.Chain(bijectors))
def __init__(self,active_dims=[0],decay=0.1,max_subsequence_length=3,
alphabet = [], maxlen=0, batch_size=100):
super().__init__(active_dims=active_dims)
# constrain decay kernel params to between 0 and 1
self.logistic = tfb.Chain([tfb.Shift(tf.cast(0,tf.float64))(tfb.Scale(tf.cast(1,tf.float64))),tfb.Sigmoid()])
self.decay_param= Parameter(decay, transform=self.logistic ,name="decay")
# use will use copies of the kernel params to stop building expensive computation graph
# we instead efficientely calculate gradients using dynamic programming
# These params are updated at every call to K and K_diag (to check if parameters have been updated)
self.decay = self.decay_param.numpy()
self.decay_unconstrained = self.decay_param.unconstrained_variable.numpy()
self.order_coefs=tf.ones(max_subsequence_length,dtype=tf.float64)
# store additional kernel parameters
self.max_subsequence_length = tf.constant(max_subsequence_length)
self.alphabet = tf.constant(alphabet)
self.alphabet_size=tf.shape(self.alphabet)[0]
self.maxlen = tf.constant(maxlen)
self.batch_size = tf.constant(batch_size)
# build a lookup table of the alphabet to encode input strings
self.table = tf.lookup.StaticHashTable(
initializer=tf.lookup.KeyValueTensorInitializer(
keys=tf.constant(["PAD"]+alphabet),
values=tf.constant(range(0,len(alphabet)+1)),),default_value=0)
# initialize helful construction matricies to be lazily computed once needed
self.D = None
self.dD_dgap = None
def __init__(self,rank=1,active_dims=[0],gap_decay=0.1, match_decay=0.9,max_subsequence_length=3,
alphabet = [], maxlen=0):
super().__init__(active_dims=active_dims)
# constrain decay kernel params to between 0 and 1
logistic_gap = tfb.Chain([tfb.Shift(tf.cast(0,tf.float64))(tfb.Scale(tf.cast(1,tf.float64))),tfb.Sigmoid()])
logisitc_match = tfb.Chain([tfb.AffineScalar(shift=tf.cast(0,tf.float64),scale=tf.cast(1,tf.float64)),tfb.Sigmoid()])
self.gap_decay= Parameter(gap_decay, transform=logistic_gap ,name="gap_decay")
self.match_decay = Parameter(match_decay, transform=logisitc_match,name="match_decay")
# prepare similarity matrix parameters
self.rank=rank
W = 0.1 * tf.ones((len(alphabet), self.rank))
kappa = tf.ones(len(alphabet))
self.W = Parameter(W,name="W")
self.kappa = Parameter(kappa, transform=positive(),name="kappa")
# store additional kernel parameters
self.max_subsequence_length = tf.constant(max_subsequence_length)
self.alphabet = tf.constant(alphabet)
self.alphabet_size=tf.shape(self.alphabet)[0]
self.maxlen = tf.constant(maxlen)
# build a lookup table of the alphabet to encode input strings
self.table = tf.lookup.StaticHashTable(
initializer=tf.lookup.KeyValueTensorInitializer(
keys=tf.constant(["PAD"]+alphabet),
values=tf.constant(range(0,len(alphabet)+1)),),default_value=0)
def from_loc_and_scale(cls,
loc,
scale,
low=0.,
high=1e10,
scale_shift=1e-7):
"""
Instantiate a learnable distribution with good default bijectors.
loc : array
The initial location of the distribution
scale : array
The initial scale parameter of the distribution
low : float or array (optional)
The lower limit of the support for the distribution.
high : float or array (optional)
The upper limit of the support for the distribution.
scale_shift : float (optional)
A small constant added to the scale to increase numerical stability.
"""
loc = tfp.util.TransformedVariable(
loc,
tfb.Softplus(),
)
scale = tfp.util.TransformedVariable(
scale,
tfb.Chain([
tfb.Softplus(),
tfb.Shift(scale_shift),
]),
)
return cls(loc, scale, low, high)
def __init__(self,
m=1,
active_dims=[0],
gap_decay=0.1,
match_decay=0.9,
max_subsequence_length=3,
alphabet=[],
maxlen=0):
super().__init__(active_dims=active_dims)
# constrain decay kernel params to between 0 and 1
logistic_gap = tfb.Chain([
tfb.Shift(tf.cast(0, tf.float64))(tfb.Scale(tf.cast(1,
tf.float64))),
tfb.Sigmoid()
])
logisitc_match = tfb.Chain([
tfb.AffineScalar(shift=tf.cast(0, tf.float64),
scale=tf.cast(1, tf.float64)),
tfb.Sigmoid()
])
self.gap_decay = Parameter(gap_decay,
transform=logistic_gap,
name="gap_decay")
self.match_decay = Parameter(match_decay,
transform=logisitc_match,
name="match_decay")
# prepare order coefs params
order_coefs = tf.ones(max_subsequence_length)
self.order_coefs = Parameter(order_coefs,
transform=positive(),
name="order_coefs")
# get split weights
self.m = m
split_weights = tf.ones(2 * self.m - 1)
self.split_weights = Parameter(split_weights,
transform=positive(),
name="order_coefs")
# store additional kernel parameters
self.max_subsequence_length = tf.constant(max_subsequence_length)
self.alphabet = tf.constant(alphabet)
self.alphabet_size = tf.shape(self.alphabet)[0]
self.maxlen = tf.cast(tf.math.ceil(maxlen / self.m), dtype=tf.int32)
self.full_maxlen = tf.constant(maxlen)
# build a lookup table of the alphabet to encode input strings
self.table = tf.lookup.StaticHashTable(
initializer=tf.lookup.KeyValueTensorInitializer(
keys=tf.constant(["PAD"] + alphabet),
values=tf.constant(range(0,
len(alphabet) + 1)),
),
default_value=0)
def __init__(self, shift=None, scale=None, **kwargs):
if scale is None:
scaling = tfb.Identity()
else:
scaling = tfb.Scale(scale)
if shift is None:
shifting = tfb.Identity()
else:
shifting = tfb.Shift(shift)
transform = tfb.Chain([scaling, shifting])
super().__init__(transform, **kwargs)
def __init__(self, upper_limit):
transform = tfb.Chain(
[tfb.Shift(upper_limit),
tfb.Scale(-1), tfb.Exp()])
super().__init__(transform)
def __init__(self, lower_limit):
transform = tfb.Chain([tfb.Shift(lower_limit), tfb.Exp()])
super().__init__(transform)
