def __init__(self, data, Y_var): super().__init__(active_dims=[0]) self.Y_var = Y_var self.num_genes = data.m_obs.shape[1] # l_affine = tfb.AffineScalar(shift=tf.cast(1., tf.float64), # scale=tf.cast(4-1., tf.float64)) # l_sigmoid = tfb.Sigmoid() # l_logistic = tfb.Chain([l_affine, l_sigmoid]) self.lengthscale = gpflow.Parameter(1.414, transform=positive()) D_affine = tfb.AffineScalar(shift=tf.cast(0.1, tf.float64), scale=tf.cast(1.5 - 0.1, tf.float64)) D_sigmoid = tfb.Sigmoid() D_logistic = tfb.Chain([D_affine, D_sigmoid]) S_affine = tfb.AffineScalar(shift=tf.cast(0.1, tf.float64), scale=tf.cast(4. - 0.1, tf.float64)) S_sigmoid = tfb.Sigmoid() S_logistic = tfb.Chain([S_affine, S_sigmoid]) self.D = gpflow.Parameter(np.random.uniform(0.9, 1, self.num_genes), transform=positive(), dtype=tf.float64) # self.D[3].trainable = False # self.D[3].assign(0.8) self.S = gpflow.Parameter(np.random.uniform(1, 1, self.num_genes), transform=positive(), dtype=tf.float64) # self.S[3].trainable = False # self.S[3].assign(1) self.kervar = gpflow.Parameter(np.float64(1), transform=positive()) self.noise_term = gpflow.Parameter( 0.1353 * tf.ones(self.num_genes, dtype='float64'), transform=positive())
def __init__(self, active_dims=[0], gap_decay=0.1, match_decay=0.9, max_subsequence_length=3, max_occurence_length=10, alphabet=[], maxlen=0, normalize=True, batch_size=1000): super().__init__(active_dims=active_dims) # constrain kernel params to between 0 and 1 self.logistic_gap = tfb.Chain([ tfb.AffineScalar(shift=tf.cast(0, tf.float64), scale=tf.cast(1, tf.float64)), tfb.Sigmoid() ]) self.logisitc_match = tfb.Chain([ tfb.AffineScalar(shift=tf.cast(0, tf.float64), scale=tf.cast(1, tf.float64)), tfb.Sigmoid() ]) self.gap_decay_param = Parameter(gap_decay, transform=self.logistic_gap, name="gap_decay") self.match_decay_param = Parameter(match_decay, transform=self.logisitc_match, name="match_decay") self.max_subsequence_length = max_subsequence_length self.max_occurence_length = max_occurence_length self.alphabet = alphabet self.maxlen = maxlen self.normalize = normalize self.batch_size = batch_size self.symmetric = False # 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.match_decay = self.match_decay_param.numpy() self.gap_decay = self.gap_decay_param.numpy() self.match_decay_unconstrained = self.match_decay_param.unconstrained_variable.numpy( ) self.gap_decay_unconstrained = self.gap_decay_param.unconstrained_variable.numpy( ) # initialize helful construction matricies to be lazily computed once needed self.D = None self.dD_dgap = None # 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, 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_distribution(conditions): loc, scale = conditions["loc"], conditions["scale"] return tfd.TransformedDistribution( distribution=tfd.Normal(loc=loc, scale=scale), bijector=bij.Sigmoid(), name="LogitNormal", )
def _build(self, inputs): mean, covariance, scale = self.create_mean_n_cov_layers(inputs) #TODO is this the kind of regularization we want. I think it makes sense. self.set_contractive_regularizer(mean, covariance, self._contractive_regularizer_inputs, self._contractive_regularizer_tuple, self._contractive_collection_network_str) gaussian = tfd.Normal(loc=mean, scale=scale) sigmoid_bijector = tfb.Sigmoid() logitnormal = tfd.TransformedDistribution(distribution = gaussian, bijector = sigmoid_bijector) # add reconstruction_node method (needed to some sort of mean or median to get reconstructions without sampling) def reconstruction_node(self): # this is because there is not been for the LogitNormalDiagonal distribution return sigmoid_bijector.forward(gaussian.mean()) logitnormal.reconstruction_node = types.MethodType(reconstruction_node, logitnormal) clip_value = self._clip_value # make sure a rescale the input for log_prob def log_prob(self, x, name='log_prob', **kwargs): # kinda of dirty I know, it is used to avoid recursion (Luigi) return self._call_log_prob(tf_clip(x, low=-1.0 + clip_value, high=1.0 -clip_value), name=name, **kwargs) logitnormal.log_prob = types.MethodType(log_prob, logitnormal) return logitnormal
def bounded_parameter(low, high, param): """Make parameter tfp Parameter with optimization bounds.""" affine = tfb.AffineScalar(shift=tf.cast(low, tf.float64), scale=tf.cast(high - low, tf.float64)) sigmoid = tfb.Sigmoid() logistic = tfb.Chain([affine, sigmoid]) parameter = gpf.Parameter(param, transform=logistic, dtype=tf.float64) return parameter
def bounded_parameter(low, high, param): """Make parameter tfp Parameter with optimization bounds.""" sigmoid = tfb.Sigmoid(low=tf.cast(low, tf.float64), high=tf.cast(high, tf.float64), name='sigmoid') parameter = gpf.Parameter(param, transform=sigmoid, dtype=tf.float64) return parameter
def __init__(self, *args, **kwargs): """Initialize UnitContinuousRV. Developer Note -------------- The inverse of the sigmoid bijector is the logodds bijector. """ super().__init__(*args, **kwargs) self._transformed_distribution = tfd.TransformedDistribution( distribution=self._distribution, bijector=bijectors.Invert(bijectors.Sigmoid()))
def test_additional_event_ndims(self): bij = tfb.Sigmoid(low=tf.zeros([2]), high=tf.ones([3, 2])) self.assertAllEqual(batch_shape_lib.inferred_batch_shape(bij), [3, 2]) self.assertAllEqual(batch_shape_lib.inferred_batch_shape_tensor(bij), [3, 2]) self.assertAllEqual( batch_shape_lib.inferred_batch_shape(bij, additional_event_ndims=1), [3]) self.assertAllEqual( batch_shape_lib.inferred_batch_shape_tensor( bij, additional_event_ndims=1), [3])
def test_bijector_event_ndims(self): bij = tfb.Sigmoid(low=tf.zeros([2]), high=tf.ones([3, 2])) self.assertAllEqual(batch_shape_lib.inferred_batch_shape(bij), [3, 2]) self.assertAllEqual(batch_shape_lib.inferred_batch_shape_tensor(bij), [3, 2]) self.assertAllEqual( batch_shape_lib.inferred_batch_shape(bij, bijector_x_event_ndims=1), [3]) self.assertAllEqual( batch_shape_lib.inferred_batch_shape_tensor( bij, bijector_x_event_ndims=1), [3]) # Verify that we don't pass Nones through to component # `experimental_batch_shape(x_event_ndims=None)` calls, where they'd be # incorrectly interpreted as `x_event_ndims=forward_min_event_ndims`. joint_bij = tfb.JointMap([bij, bij]) self.assertAllEqual( batch_shape_lib.inferred_batch_shape( joint_bij, bijector_x_event_ndims=[None, None]), tf.TensorShape(None))
def __init__(self): transform = tfb.Sigmoid() super().__init__(transform)
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
tf.ones([], dtype, name='alpha') * 0.5, tf.fill(ncomponents - 1, value=np.float64(0.5), name='v') ] # Create bijectors to transform unconstrained to and from constrained parameters-space. # For example, if X ~ Exponential(theta), then X is constrained to be positive. A transformation # that puts X onto an unconstrained space is Y = log(X). In that case, the bijector used # should be the **inverse-transform**, which is exp(.) (i.e. so that X = exp(Y)). # # NOTE: Define the inverse-transforms for each parameter in sequence. bijectors = [ tfb.Identity(), # mu tfb.Exp(), # sigma tfb.Exp(), # alpha tfb.Sigmoid() # v ] # ## HMC # In[16]: # Define HMC sampler. @tf.function(autograph=False, experimental_compile=True) def hmc_sample(num_results, num_burnin_steps, current_state, step_size=0.01, num_leapfrog_steps=100):
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)
class UnitContinuousRV(RandomVariable): _bijector = bijectors.Sigmoid()
def __init__(self, lower_limit, upper_limit): transform = tfb.Sigmoid(low=lower_limit, high=upper_limit) super().__init__(transform)
mix_T(gamma_C, gamma_T, eta_C, eta_T, p, loc, tf.sqrt( sigma_sq), dtype(neg_inf)), n_T))) # TEST n_C = 4 n_T = 6 K = 3 model = create_model(n_C=n_C, n_T=n_T, K=K) s = model.sample() s model.log_prob(s) # model.sample(2) # FIXME bijectors = [ tfb.Sigmoid(), # p tfb.Sigmoid(), # gamma_C tfb.Sigmoid(), # gamma_T tfb.SoftmaxCentered(), # eta_C tfb.SoftmaxCentered(), # eta_T tfb.Identity(), # loc tfb.Exp() # sigma_sq ] d1 = util.read_data('../../data/TGFBR2/cytof-data/donor1.csv', 'CD16', 2000, 2) model = create_model(n_C=d1['y_C'].shape[0], n_T=d1['y_T'].shape[0], K=5) _ = model.sample() def target_log_prob_fn(p, gamma_C, gamma_T, eta_C, eta_T, loc, sigma_sq): return model.log_prob(p=p,
def __init__(self): self._transform = tfb.Sigmoid()