def sample(z, size, c1=None, c2=None, c3=None, c4=None, c5=None): if c1 is not None: z_con1 = np.array([c1] * size) z_con1 = np.reshape(z_con1, [size, 1]) else: z_con1 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if c2 is not None: z_con2 = np.array([c2] * size) z_con2 = np.reshape(z_con2, [size, 1]) else: z_con2 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if c3 is not None: z_con3 = np.array([c3] * size) z_con3 = np.reshape(z_con3, [size, 1]) else: z_con3 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if c4 is not None: z_con4 = np.array([c4] * size) z_con4 = np.reshape(z_con4, [size, 1]) else: z_con4 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if c5 is not None: z_con5 = np.array([c5] * size) z_con5 = np.reshape(z_con5, [size, 1]) else: z_con5 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) noise = tf.concat([z, z_con1, z_con2, z_con3, z_con4, z_con5], axis=-1) return noise
def sample(size, cat=-1, c1=None, c2=None): z = tfd.Uniform(low=-1.0, high=1.0).sample([size, 62]) if c1 is not None: z_con1 = np.array([c1] * size) z_con1 = np.reshape(z_con1, [size, 1]) else: z_con1 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if c2 is not None: z_con2 = np.array([c2] * size) z_con2 = np.reshape(z_con2, [size, 1]) else: z_con2 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) if cat >= 0: z_cat = np.array([cat] * size) z_cat = tf.one_hot(z_cat, 10) else: z_cat = tfd.Categorical(probs=tf.ones([10]) * 0.1).sample([ size, ]) z_cat = tf.one_hot(z_cat, 10) noise = tf.concat([z, z_con1, z_con2, z_cat], axis=-1) return noise, z_con1, z_con2, z_cat
def setup_and_run_hmc(threadid): np.random.seed(threadid) tf.random.set_seed(threadid) def sp(x): # softplus transform with shift return tf.nn.softplus(x) #+1e-4 def periodic_kernel(x1, x2): # periodic kernel with single variable parameter. Other parameters are set # to encode daily activity pattern (period=1) and lengthscale of 30 minutes return tfp.math.psd_kernels.ExpSinSquared(x1, x2, np.float64(1.0)) # initial value of kernel amplitude aparams_init = [0.0, 1.0, 0.1] lparams_init = [0.0] # transform for parameter to ensure positive atransforms = [sp, sp] # prior distribution on parameter apriors = [ tfd.Uniform(low=np.float64(-100.), high=np.float64(100.0)), tfd.Normal(loc=np.float64(0.), scale=np.float64(10.)), tfd.Normal(loc=np.float64(0.), scale=np.float64(10.)) ] lpriors = [tfd.Uniform(low=np.float64(-100.), high=np.float64(100.0))] # create the model mover = moveNS(T, X, Z, BATCH_SIZE=1000, lparams_init=lparams_init, lpriors=lpriors, akernel=periodic_kernel, aparams_init=aparams_init, apriors=apriors, atransforms=atransforms) start = time.time() # sample from the posterior #mover.hmc_sample(num_samples=2000, skip=0, burn_in=1000) mover.hmc_sample(num_samples=2000, skip=0, burn_in=1000) end = time.time() z_len = 720 Zp = T[: z_len] # process the samples and save them for the amplitude kernel amps = np.power(mover.get_amplitude_samples(X=Zp), 2) np.save('data/amps_periodic_' + str(threadid) + '.npy', amps) print(threadid, end - start)
def _model(): p = yield Root(tfd.Beta(dtype(1), dtype(1), name="p")) gamma_C = yield Root(tfd.Beta(dtype(1), dtype(1), name="gamma_C")) gamma_T = yield Root(tfd.Beta(dtype(1), dtype(1), name="gamma_T")) eta_C = yield Root(tfd.Dirichlet(np.ones(K, dtype=dtype) / K, name="eta_C")) eta_T = yield Root(tfd.Dirichlet(np.ones(K, dtype=dtype) / K, name="eta_T")) loc = yield Root(tfd.Sample(tfd.Normal(dtype(0), dtype(1)), sample_shape=K, name="loc")) nu = yield Root(tfd.Sample(tfd.Uniform(dtype(10), dtype(50)), sample_shape=K, name="nu")) phi = yield Root(tfd.Sample(tfd.Normal(dtype(m_phi), dtype(s_phi)), sample_shape=K, name="phi")) sigma_sq = yield Root(tfd.Sample(tfd.InverseGamma(dtype(3), dtype(2)), sample_shape=K, name="sigma_sq")) scale = np.sqrt(sigma_sq) gamma_T_star = compute_gamma_T_star(gamma_C, gamma_T, p) eta_T_star = compute_eta_T_star(gamma_C[..., tf.newaxis], gamma_T[..., tf.newaxis], eta_C, eta_T, p[..., tf.newaxis], gamma_T_star[..., tf.newaxis]) # likelihood y_C = yield mix(nC, eta_C, loc, scale, name="y_C") n0C = yield tfd.Binomial(nC, gamma_C, name="n0C") y_T = yield mix(nT, eta_T_star, loc, scale, name="y_T") n0T = yield tfd.Binomial(nT, gamma_T_star, name="n0T")
def actor(self, feat): shape = feat.shape[:-1] + [self._config.num_actions] if self._config.actor_dist == 'onehot': return tools.OneHotDist(tf.zeros(shape)) else: ones = tf.ones(shape, self._float) return tfd.Uniform(-ones, ones)
def actor(self, feat): shape = feat.shape[:-1] + self.act_space.shape if self.config.actor.dist == 'onehot': return common.OneHotDist(tf.zeros(shape)) else: dist = tfd.Uniform(-tf.ones(shape), tf.ones(shape)) return tfd.Independent(dist, 1)
def _base_dist(self, *args, **kwargs): """ Weibull base distribution. The inverse of the Weibull bijector applied to a U[0, 1] random variable gives a Weibull-distributed random variable. """ return tfd.TransformedDistribution( distribution=tfd.Uniform(low=0.0, high=1.0), bijector=tfp.bijectors.Invert( tfp.bijectors.Weibull(*args, **kwargs)), name="Weibull", )
def __init__(self, data, options): self.kernel = options.kernel self.options = options self.τ = data.τ self.N_p = data.τ.shape[0] self.num_tfs = data.f_obs.shape[1] t_1, t_2 = get_time_square(self.τ, self.N_p) self.t_dist = t_1 - t_2 self.tt = t_1 * t_2 self.t2 = tf.square(t_1) self.tprime2 = tf.square(t_2) self.fixed_dist = FixedDistribution( tf.ones(self.num_tfs, dtype='float64')) min_dist = min(data.t[1:] - data.t[:-1]) min_dist = max(min_dist, 1.) self._ranges = { 'rbf': [ (f64(1e-4), f64(5)), #1+max(np.var(data.f_obs, axis=2)) (f64(min_dist**2) - 1.2, f64(data.t[-1]**2)) ], 'mlp': [(f64(1), f64(10)), (f64(3.5), f64(20))], } self._priors = { 'rbf': [ tfd.Uniform(f64(1), f64(20)), tfd.Uniform(f64(min_dist**2), f64(10)) ], 'mlp': [ tfd.Uniform(f64(3.5), f64(10)), tfd.InverseGamma(f64(0.01), f64(0.01)) ], } v_prop = lambda v: tfd.TruncatedNormal(v, 0.007, low=0, high=100) l2_prop = lambda l2: tfd.TruncatedNormal(l2, 0.007, low=0, high=100) proposals = [v_prop, l2_prop] self._proposals = { 'rbf': proposals, } self._names = {'rbf': ['v', 'l2'], 'mlp': ['w', 'b']}
def sample_batch(n_samples, max_dim, max_power, dtype): """ Calculate a sum of distance samples for various dimensions and norms Generates a batch of *n_samples* of pairs of points, and uses those points to build a table of 1 to *max_dim* rows and 1 to *max_power* columns, where each entry is the sum across all samples of the distance metric with the given power for pairs of points in the given dimensional hypercube. """ # create two lists of random points and their vector difference, # where the first dimension is the sample number and the second the # coordinates for the sample zero = tf.zeros((), dtype=dtype) # used to pass in dtype to Uniform x1s = tfd.Uniform(low=zero).sample((n_samples, max_dim)) x2s = tfd.Uniform(low=zero).sample((n_samples, max_dim)) vector_difference = x2s - x1s # add a third dimension to the tensor which is the vector coordinate # raised to ascending powers (eg x, x^2, x^3...) sum_terms = tf.abs( tfm.cumprod(tf.tile( tf.reshape(vector_difference, (n_samples, max_dim, 1)), (1, 1, max_power)), axis=2)) # generate cumulative sums along the coordinate (second) dimension # and raise the sum to the 1/n power (where n is the third dimension) # to generate a new tensor where the first dimension is the samples, # the second the dimension of the hypercube, and the third the power # of the norm. norm = tfm.pow( tfm.cumsum(sum_terms, axis=1), tf.reshape(1 / tf.cast(tf.range(1, max_power + 1), dtype=dtype), (1, 1, max_power))) # return the sum of the norms return tf.reduce_sum(norm, axis=0)
def get_one_sample_untransformed(shape, distribution_type, distribution_params, seed): """Get one untransoformed sample.""" if distribution_type == DistributionType.UNIFORM: low, high = distribution_params["low"], distribution_params["high"] distribution = tfd.Uniform(low=tf.constant(low, shape=shape[1:]), high=tf.constant( high, shape=shape[1:], )) sample = distribution.sample(shape[0], seed=seed) elif distribution_type == DistributionType.LOG_UNIFORM: low, high = distribution_params["low"], distribution_params["high"] distribution = tfd.Uniform(low=tf.constant(np.log(low), shape=shape[1:], dtype=tf.float32), high=tf.constant(np.log(high), shape=shape[1:], dtype=tf.float32)) sample = tf.exp(distribution.sample(shape[0], seed=seed)) else: raise ValueError( "Unknown distribution type {}".format(distribution_type)) return sample
def _init_distribution(conditions): concentration, scale = conditions["concentration"], conditions["scale"] scale_tensor, concentration_tensor = ( tf.convert_to_tensor(scale), tf.convert_to_tensor(concentration), ) broadcast_shape = dist_util.prefer_static_broadcast_shape( scale_tensor.shape, concentration_tensor.shape ) return tfd.TransformedDistribution( distribution=tfd.Uniform(low=tf.zeros(broadcast_shape), high=tf.ones(broadcast_shape)), bijector=bij.Invert(bij.WeibullCDF(scale=scale, concentration=concentration)), name="Weibull", )
def polar1(save=False): input_dim = 2 inn = INN(64, input_dim, -1.0, 1.0) inn.load_weights("./network/polar1.tf") inn.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001, beta_1=0.99, beta_2=0.999, amsgrad=False), loss='mse', metrics=['accuracy']) loc1 = np.asarray([3.0, 0.0]) loc2 = np.zeros(6) s = tfd.Sample(tfd.Uniform(low=[0.1, -5.0], high=[5.0, 5.0])) s2 = tfd.Sample(tfd.Normal(loc=loc2, scale=0.05)) for i in range(0): x, y = s.sample(10000).numpy().T x_t = np.asarray([x, y]).T r, phi = polar(x, y) y_t = np.asarray([r, phi]).T inn.fit(x_t, y_t, epochs=2, batch_size=256, verbose=2) x, y = np.random.normal(4.0, 1.0, (600)), np.random.normal(0.0, 1.0, (600)) x_t = np.asarray([x, y]).T r, phi = polar(x, y) x_t = np.asarray([x, y]).T #network input rp, phip = inn.predict(x_t).T y_t = np.asarray([r, phi]).T #inverse network input xp, yp = inn.inv(y_t).numpy().T # print(np.mean(np.abs(r-rr))) # print(np.mean(np.abs(phi-rphi))) # for polar1forward------------------------------------------------------------ fig = py.figure(figsize=(11, 9)) fig.subplots_adjust(left=0.2, right=0.95, bottom=0.2, top=0.95) ax = fig.add_subplot(111) ax.plot(rp * np.cos(phip), rp * np.sin(phip), 'ro', label='transformed') ax.plot(x, y, 'go', label='original') ax.set_xlabel("X", fontsize=30) ax.set_ylabel("Y", fontsize=30) ax.tick_params(axis='both', which='major', labelsize=29) ax.legend(fontsize=25) if save: fig.savefig('polar1forward.png', dpi=300) # for polar1backward - ------------------------------------------------------ fig = py.figure(figsize=(10,9)) fig = py.figure(figsize=(11, 9)) fig.subplots_adjust(left=0.2, right=0.95, bottom=0.2, top=0.95) ax = fig.add_subplot(111) ax.plot(xp, yp, 'ro', label='inverse transformed') ax.plot(x, y, 'go', label='original') ax.set_xlabel("X", fontsize=30) ax.set_ylabel("Y", fontsize=30) ax.tick_params(axis='both', which='major', labelsize=29) ax.legend(fontsize=25) if save: fig.savefig('polar1backward.png', dpi=300) # py.show() # for polar1mesh----------------------------------------- # rr, rphi = polar(xmesh,ymesh) # out = inn.predict(mesh) # r,phi = out.T # y_t = np.asarray([rr,rphi]).T # out = inn.inv(y_t).numpy() # xr,yr = out.T # fig = py.figure(figsize=(15,15)) # fig.subplots_adjust(left=0.1,right = 0.9,bottom=0.2,top=0.8) # ax = fig.add_subplot(111) # ax.plot(r*np.cos(phi),r*np.sin(phi),'bo',label ='transformed') # ax.plot(xr,yr,'ro',label='inverse transform') # ax.plot(xmesh,ymesh,'go',label='original',alpha=0.5) # ax.set_xlabel("X",fontsize=25) # ax.set_ylabel("Y",fontsize=25) # ax.tick_params(axis='both', which='major', labelsize=24) # ax.legend(fontsize = 20) # if save: # fig.savefig('polar1mesh.png',dpi=300) py.show() # inn.save_weights('./network/polar1.tf') return None
def _base_dist(self, lower: TensorLike, upper: TensorLike, *args, **kwargs): return tfd.Uniform(low=lower, high=upper, *args, **kwargs)
def make_model(well_complex, well_ligand, fi_complex, fi_ligand, debug = False, kernel = 'random_walk_metropolis', num_results = 1000, num_burnin_steps = 300): """Build a tfp model for an assay that consists of N wells of protein:ligand at various concentrations and an additional N wells of ligand in buffer, with the ligand at the same concentrations as the corresponding protein:ligand wells. Parameters ---------- well_complex : titration.SingleWell, the main titration cell well_ligand : titration.SingleWell, the reference cell fi_complex : np.ndarray, measured fluorescense intensity of complex cell fi_ligand : np.ndarray, measured fluorescense intensity of the reference cell debug : (Default value = False) kernel : (Default value = 'random_walk_metropolis') num_results : (Default value = 1000) num_burnin_steps : (Default value = 300) Returns ------- """ n_wells = fi_complex.shape[0] # define max and min fluorescense intensity fi_max = np.max([np.max(fi_complex), np.max(fi_ligand)]) fi_min = np.min([np.min(fi_complex), np.min(fi_ligand)]) # grab the path_length from the wells assert well_complex.path_length == well_ligand.path_length path_length = tf.constant(well_complex.path_length, dtype=tf.float32) # grab the concentrations rv from the complex well concs_p_complex_rv = well_complex.concs_p_rv concs_l_complex_rv = well_complex.concs_l_rv # grab the concentrations rv from the ligand plate concs_l_ligand_rv = well_ligand.concs_l_rv # the guesses, to be used as initial state delta_g_guess = tf.constant(-1.0, dtype=tf.float32) # kT # use the value from ChEMBL concs_p_complex_guess = tf.constant(well_complex.concs[0, :], dtype=tf.float32) concs_l_complex_guess = tf.constant(well_complex.concs[1, :], dtype=tf.float32) concs_l_ligand_guess = tf.constant(well_ligand.concs[1, :], dtype=tf.float32) fi_pl_guess = tf.constant(np.true_divide(fi_max - fi_min, np.min([np.max(concs_p_complex_guess), np.max(concs_l_complex_guess)])), dtype=tf.float32) fi_p_guess = tf.constant(fi_min, dtype=tf.float32) fi_l_guess = tf.constant(np.true_divide(fi_max-fi_min, np.max(concs_l_complex_guess)), dtype=tf.float32) fi_plate_guess = tf.constant(fi_min, dtype=tf.float32) fi_buffer_guess = tf.constant(np.true_divide(fi_min, path_length), dtype=tf.float32) fi_complex_guess = tf.constant(fi_complex, dtype=tf.float32) fi_ligand_guess = tf.constant(fi_ligand, dtype=tf.float32) # jeffrey_log_sigma_complex_guess = tf.constant(np.tile([0.5 * (np.log(fi_max)-10.0)], (n_wells,)), dtype=tf.float32) # jeffrey_log_sigma_ligand_guess = tf.constant(np.tile([0.5 * (np.log(fi_max)-10.0)], (n_wells,)), dtype=tf.float32) jeffrey_log_sigma_complex_guess = tf.constant(np.tile([np.log(2)], (n_wells,)), dtype=tf.float32) jeffrey_log_sigma_ligand_guess = tf.constant(np.tile([np.log(2)], (n_wells,)), dtype=tf.float32) #====================================================================== # Define a whole bunch of rv #====================================================================== # TODO: not sure which way is faster: # define rv inside or outside this function? # define free energy prior delta_g_rv = tfd.Uniform(low=tf.log(tf.constant(1e-15, dtype=tf.float32)), high=tf.constant(0.0, dtype=tf.float32)) # define fluorescense intensity prior fi_plate_rv = tfd.Uniform(low=tf.constant(0.0, dtype=tf.float32), high=tf.constant(fi_max, dtype=tf.float32)) fi_buffer_rv = tfd.Uniform(low=tf.constant(0.0, dtype=tf.float32), high=tf.constant(np.true_divide(fi_max, path_length), dtype=tf.float32)) fi_pl_rv = tfd.Uniform(low=tf.constant(0.0, dtype=tf.float32), high=tf.constant(2*np.max([np.max(np.true_divide(fi_max, concs_p_complex_guess)), np.max(np.true_divide(fi_max, concs_l_complex_guess))]), dtype=tf.float32)) fi_p_rv = tfd.Uniform(low=tf.constant(0.0, dtype=tf.float32), high=tf.constant(2*np.max(np.true_divide(fi_max, concs_p_complex_guess)), dtype=tf.float32)) fi_l_rv = tfd.Uniform(low=tf.constant(0.0, dtype=tf.float32), high=tf.constant(2*np.max(np.true_divide(fi_max, concs_l_complex_guess)), dtype=tf.float32)) jeffrey_log_sigma_rv = tfd.Uniform(low=tf.constant(np.tile([-1.0], (n_wells,)), dtype=tf.float32), high=tf.constant(np.tile([np.log(10)], (n_wells,)), dtype=tf.float32)) rvs = None trajs = None if debug == True: rvs = [ delta_g_rv, fi_plate_rv, fi_buffer_rv, fi_pl_rv, fi_p_rv, fi_l_rv, concs_p_complex_rv, concs_l_complex_rv, concs_l_ligand_rv, jeffrey_log_sigma_rv ] trajs = [np.array([]) for dummy_idx in range(11)] current_state=[ delta_g_guess, fi_plate_guess, fi_buffer_guess, fi_pl_guess, fi_p_guess, fi_l_guess, fi_complex_guess, fi_ligand_guess, concs_p_complex_guess, concs_l_complex_guess, concs_l_ligand_guess, jeffrey_log_sigma_complex_guess, jeffrey_log_sigma_ligand_guess, ] # define the joint_log_prob function to be used in MCMC def joint_log_prob(delta_g, # primary parameters to INFER fi_plate = fi_plate_guess, fi_buffer = fi_buffer_guess, fi_pl = fi_pl_guess, fi_p = fi_p_guess, fi_l = fi_l_guess, # fluorescence intesensity to INFER fi_complex = fi_complex_guess, fi_ligand = fi_ligand_guess, concs_p_complex = concs_p_complex_guess, concs_l_complex = concs_l_complex_guess, # primary parameters to INFER concs_l_ligand = concs_l_ligand_guess, # primary parameters to INFER jeffrey_log_sigma_complex = jeffrey_log_sigma_complex_guess, jeffrey_log_sigma_ligand = jeffrey_log_sigma_ligand_guess): # TODO: figure out a way to get rid of this #====================================================================== # Calculate the relationships between the observed values, # the values to infer, and the constants. #====================================================================== # using a binding model, get the true concentrations of protein, ligand, # and protein-ligand complex concs_p_, concs_l_, concs_pl_ = equilibrium_concentrations(delta_g, concs_p_complex, concs_l_complex) # predict observed fluorescence intensity fi_complex_ = fi_p * concs_p_ + fi_l * concs_l_ + fi_pl * concs_pl_ + path_length * fi_buffer + fi_plate fi_ligand_ = fi_l * concs_l_ligand + path_length * fi_buffer + fi_plate # make this rv inside the function, since it changes with jeffery_log_sigma fi_complex_rv = tfd.Normal(loc=tf.constant(fi_complex, dtype=tf.float32), scale=tf.square(tf.exp(jeffrey_log_sigma_complex))) fi_ligand_rv = tfd.Normal(loc=tf.constant(fi_ligand, dtype=tf.float32), scale=tf.square(tf.exp(jeffrey_log_sigma_ligand))) #====================================================================== # Sum up the log_prob. #====================================================================== # NOTE: this is very weird. the LogNormal offered by tfp # is actually just normal distribution but with transformation before input # so you have to transfer again yourself log_prob = (delta_g_rv.log_prob(delta_g) # initialize a log_prob + fi_plate_rv.log_prob(fi_plate) + fi_buffer_rv.log_prob(fi_buffer) + fi_pl_rv.log_prob(fi_pl) + fi_p_rv.log_prob(fi_p) + fi_l_rv.log_prob(fi_l) + tf.reduce_sum(fi_complex_rv.log_prob(fi_complex_)) + tf.reduce_sum(fi_ligand_rv.log_prob(fi_ligand_)) + concs_p_complex_rv.log_prob(tf.exp(concs_p_complex)) + concs_l_complex_rv.log_prob(tf.exp(concs_l_complex)) + concs_l_ligand_rv.log_prob(tf.exp(concs_l_ligand)) # + concs_p_complex_rv.log_prob(concs_p_complex) # + concs_l_complex_rv.log_prob(concs_l_complex) # + concs_l_ligand_rv.log_prob(concs_l_ligand) + tf.reduce_sum(jeffrey_log_sigma_rv.log_prob(jeffrey_log_sigma_complex)) + tf.reduce_sum(jeffrey_log_sigma_rv.log_prob(jeffrey_log_sigma_ligand))) if debug == True: # plot trajectories of the inference for idx, value in enumerate([delta_g, fi_plate, fi_buffer, fi_pl, fi_p, fi_l, concs_p_complex, concs_l_complex, concs_l_ligand, jeffrey_log_sigma_complex, jeffrey_log_sigma_ligand]): if value.ndim == 0: trajs[idx] = np.append(trajs[idx], value.numpy()) else: if trajs[idx].size == 0: trajs[idx] = np.expand_dims(value.numpy(), axis=0) else: trajs[idx] = np.concatenate([trajs[idx], np.expand_dims(value.numpy(), axis=0)], axis=0) return log_prob # HamiltonianMonteCarlo implementation if kernel == 'hamiltonian_monte_carlo': # put the log_prob function and initial guesses into a mcmc chain chain_states, kernel_results = tfp.mcmc.sample_chain( num_results=int(num_results), num_burnin_steps=int(num_burnin_steps), parallel_iterations=1, current_state=current_state, kernel=tfp.mcmc.TransformedTransitionKernel( bijector=[ tfp.bijectors.Identity(), # delta_g tfp.bijectors.Identity(), tfp.bijectors.Identity(), #fi_plate, fi_buffer tfp.bijectors.Identity(), tfp.bijectors.Identity(), tfp.bijectors.Identity(), # fi_pl, fi_p, fi_l tfp.bijectors.Identity(), tfp.bijectors.Identity(), # fi_complex, fi_ligand tfp.bijectors.Tanh(), tfp.bijectors.Tanh(), # concs_p_complex, concs_l_complex tfp.bijectors.Tanh(), # concs_l_ligand tfp.bijectors.Identity(), tfp.bijectors.Identity() # jeffrey_log_sigma_complex, jeffrey_log_sigma_ligand ], inner_kernel=tfp.mcmc.HamiltonianMonteCarlo( target_log_prob_fn=joint_log_prob, num_leapfrog_steps=2, step_size=tf.Variable(0.5), step_size_update_fn=tfp.mcmc.make_simple_step_size_update_policy() ))) elif kernel == 'random_walk_metropolis': # RandomWalkMetropolis implementation chain_states, kernel_results = tfp.mcmc.sample_chain( num_results=int(num_results), current_state=current_state, kernel=tfp.mcmc.RandomWalkMetropolis(joint_log_prob), num_burnin_steps=int(num_burnin_steps), parallel_iterations=1) return chain_states, kernel_results, rvs, trajs
z_con5 = np.array([c5] * size) z_con5 = np.reshape(z_con5, [size, 1]) else: z_con5 = tfd.Uniform(low=-1.0, high=1.0).sample([size, 1]) noise = tf.concat([z, z_con1, z_con2, z_con3, z_con4, z_con5], axis=-1) return noise number = int(input('Model number: ')) generator = tl.models.Model.load('./models/model{}.h5'.format(number), load_weights=True) generator.eval() output_image = [] cc = np.linspace(-1, 1, 10) z = tfd.Uniform(low=-1.0, high=1.0).sample([1, 128]) for i in range(5): imgs = [] z = tfd.Uniform(low=-1.0, high=1.0).sample([1, 128]) for ii in range(10): noise = sample(z, 1, c1=cc[ii]) img = generator(noise)[0] img = (img + 1.) / 2. imgs.append(np.reshape(img, [32, 32])) imgs = np.concatenate(imgs, 1) output_image.append(imgs) output_image = np.concatenate(output_image, 0) plt.figure(figsize=(15, 8)) plt.suptitle("varying continuous latent code") plt.imshow(output_image, cmap="gray")
def _init_distribution(conditions, **kwargs): low, high = conditions["low"], conditions["high"] return tfd.Uniform(low=low, high=high, **kwargs)
def sample(self): component_mean = tfd.Uniform().sample( [self._length_scale, self._var_dim]) return component_mean
from createdata import * cmin = -10. # lower range of uniform distribution on c cmax = 10. # upper range of uniform distribution on c mmu = 0. # mean of Gaussian distribution on m msigma = 10. # standard deviation of Gaussian distribution on m # convert x values and data to 32 bit float x = x.astype(np.float32) # x is being use globally here data = data.astype(np.float32) # set model - contains priors and the expected linear model model = tfd.JointDistributionSequential([ tfd.Normal(loc=mmu, scale=msigma, name="m"), # m prior tfd.Uniform(cmin, cmax, name="c"), # c prior lambda c, m: (tfd.Independent( tfd.Normal(loc=(m[..., tf.newaxis] * x + c[..., tf.newaxis]), scale=sigma), name="data", reinterpreted_batch_ndims=1, )) ]) def target_log_prob_fn(mvalue, cvalue): """Unnormalized target density as a function of states.""" return model.log_prob((mvalue, cvalue, data)) Nsamples = 2000 # final number of samples
def __init__(self, data, options): self.data = data min_dist = min(data.t[1:] - data.t[:-1]) self.N_p = data.τ.shape[0] self.N_m = data.t.shape[0] # Number of observations self.num_replicates = data.f_obs.shape[0] self.num_tfs = data.f_obs.shape[1] self.num_genes = data.m_obs.shape[1] self.kernel_selector = GPKernelSelector(data, options) self.likelihood = TranscriptionLikelihood(data, options) self.options = options # Adaptable variances a = tf.constant(-0.5, dtype='float64') b2 = tf.constant(2., dtype='float64') self.h_f = 0.15 * tf.ones(self.N_p, dtype='float64') # Interaction weights w_0 = Parameter('w_0', tfd.Normal(0, 2), np.zeros(self.num_genes), step_size=0.2 * tf.ones(self.num_genes, dtype='float64')) w_0.proposal_dist = lambda mu, j: tfd.Normal(mu, w_0.step_size[j]) w = Parameter('w', tfd.Normal(0, 2), 1 * np.ones((self.num_genes, self.num_tfs)), step_size=0.2 * tf.ones(self.num_genes, dtype='float64')) w.proposal_dist = lambda mu, j: tfd.Normal(mu, w.step_size[ j]) #) w_j) # At the moment this is the same as w_j0 (see pg.8) # Latent function fbar = Parameter( 'fbar', self.fbar_prior, 0.5 * np.ones( (self.num_replicates, self.num_tfs, self.N_p))) # GP hyperparameters V = Parameter('V', tfd.InverseGamma(f64(0.01), f64(0.01)), f64(1), step_size=0.05, fixed=not options.tf_mrna_present) V.proposal_dist = lambda v: tfd.TruncatedNormal( v, V.step_size, low=0, high=100 ) #v_i Fix to 1 if translation model is not used (pg.8) L = Parameter('L', tfd.Uniform(f64(min_dist**2 - 0.5), f64(data.t[-1]**2)), f64(4), step_size=0.05) # TODO auto set L.proposal_dist = lambda l2: tfd.TruncatedNormal( l2, L.step_size, low=0, high=100) #l2_i # Translation kinetic parameters δbar = Parameter('δbar', tfd.Normal(a, b2), f64(-0.3), step_size=0.05) δbar.proposal_dist = lambda mu: tfd.Normal(mu, δbar.step_size) # White noise for genes σ2_m = Parameter('σ2_m', tfd.InverseGamma(f64(0.01), f64(0.01)), 1e-4 * np.ones(self.num_genes), step_size=0.01) σ2_m.proposal_dist = lambda mu: tfd.TruncatedNormal( mu, σ2_m.step_size, low=0, high=0.1) # Transcription kinetic parameters constraint_index = 2 if self.options.initial_conditions else 1 def constrain_kbar(kbar, gene): '''Constrains a given row in kbar''' # if gene == 3: # kbar[constraint_index] = np.log(0.8) # kbar[constraint_index+1] = np.log(1.0) kbar[kbar < -10] = -10 kbar[kbar > 3] = 3 return kbar num_var = 4 if self.options.initial_conditions else 3 kbar_initial = -0.1 * np.ones( (self.num_genes, num_var), dtype='float64') for j, k in enumerate(kbar_initial): kbar_initial[j] = constrain_kbar(k, j) kbar = Parameter('kbar', tfd.Normal(a, b2), kbar_initial, constraint=constrain_kbar, step_size=0.05 * tf.ones(num_var, dtype='float64')) kbar.proposal_dist = lambda mu: tfd.MultivariateNormalDiag( mu, kbar.step_size) if not options.preprocessing_variance: σ2_f = Parameter('σ2_f', tfd.InverseGamma(f64(0.01), f64(0.01)), 1e-4 * np.ones(self.num_tfs), step_size=tf.constant(0.5, dtype='float64')) super().__init__( TupleParams_pre(fbar, δbar, kbar, σ2_m, w, w_0, L, V, σ2_f)) else: super().__init__(TupleParams(fbar, δbar, kbar, σ2_m, w, w_0, L, V))
def main(config): logdir = pathlib.Path(config.logdir).expanduser() config.traindir = config.traindir or logdir / 'train_eps' config.evaldir = config.evaldir or logdir / 'eval_eps' config.steps //= config.action_repeat config.eval_every //= config.action_repeat config.log_every //= config.action_repeat config.time_limit //= config.action_repeat config.act = getattr(tf.nn, config.act) if config.debug: tf.config.experimental_run_functions_eagerly(True) if config.gpu_growth: message = 'No GPU found. To actually train on CPU remove this assert.' assert tf.config.experimental.list_physical_devices('GPU'), message for gpu in tf.config.experimental.list_physical_devices('GPU'): tf.config.experimental.set_memory_growth(gpu, True) assert config.precision in (16, 32), config.precision if config.precision == 16: prec.set_policy(prec.Policy('mixed_float16')) print('Logdir', logdir) logdir.mkdir(parents=True, exist_ok=True) config.traindir.mkdir(parents=True, exist_ok=True) config.evaldir.mkdir(parents=True, exist_ok=True) step = count_steps(config.traindir) logger = tools.Logger(logdir, config.action_repeat * step) print('Create envs.') if config.offline_traindir: directory = config.offline_traindir.format(**vars(config)) else: directory = config.traindir train_eps = tools.load_episodes(directory, limit=config.dataset_size) if config.offline_evaldir: directory = config.offline_evaldir.format(**vars(config)) else: directory = config.evaldir eval_eps = tools.load_episodes(directory, limit=1) make = lambda mode: make_env(config, logger, mode, train_eps, eval_eps) train_envs = [make('train') for _ in range(config.envs)] eval_envs = [make('eval') for _ in range(config.envs)] acts = train_envs[0].action_space config.num_actions = acts.n if hasattr(acts, 'n') else acts.shape[0] prefill = max(0, config.prefill - count_steps(config.traindir)) print(f'Prefill dataset ({prefill} steps).') if hasattr(acts, 'discrete'): random_actor = tools.OneHotDist(tf.zeros_like(acts.low)[None]) else: random_actor = tfd.Independent( tfd.Uniform(acts.low[None], acts.high[None]), 1) def random_agent(o, d, s): action = random_actor.sample() logprob = random_actor.log_prob(action) return {'action': action, 'logprob': logprob}, None tools.simulate(random_agent, train_envs, prefill) tools.simulate(random_agent, eval_envs, episodes=1) logger.step = config.action_repeat * count_steps(config.traindir) print('Simulate agent.') train_dataset = make_dataset(train_eps, config) eval_dataset = iter(make_dataset(eval_eps, config)) agent = Dreamer(config, logger, train_dataset) if (logdir / 'variables.pkl').exists(): agent.load(logdir / 'variables.pkl') agent._should_pretrain._once = False state = None while agent._step.numpy().item() < config.steps: logger.write() print('Start evaluation.') video_pred = agent._wm.video_pred(next(eval_dataset)) logger.video('eval_openl', video_pred) eval_policy = functools.partial(agent, training=False) tools.simulate(eval_policy, eval_envs, episodes=1) print('Start training.') state = tools.simulate(agent, train_envs, config.eval_every, state=state) agent.save(logdir / 'variables.pkl') for env in train_envs + eval_envs: try: env.close() except Exception: pass
def _init_distribution(conditions): return tfd.Uniform(low=-np.inf, high=np.inf)
z_cat = tf.one_hot(z_cat, 10) else: z_cat = tfd.Categorical(probs=tf.ones([10])*0.1).sample([size, ]) z_cat = tf.one_hot(z_cat, 10) noise = tf.concat([z, z_con1, z_con2, z_cat], axis=-1) return noise number = int(input('Model number: ')) generator = tl.models.Model.load( './models/model{}.h5'.format(number), load_weights=True) generator.eval() output_image = [] for i in range(10): z = tfd.Uniform(low=-1.0, high=1.0).sample([5, 62]) noise = sample(z, 5, cat=i) imgs = generator(noise) imgs = (imgs + 1.) / 2. imgs = np.split(imgs, 5, 0) imgs = [np.reshape(img, [28, 28]) for img in imgs] imgs = np.concatenate(imgs, 0) output_image.append(imgs) output_image = np.concatenate(output_image, 1) plt.figure(figsize=(15, 8)) plt.suptitle("varying discrete latent code") plt.imshow(output_image, cmap="gray") plt.axis("off") plt.savefig("./test/cat_res.png")
def _init_distribution(conditions, **kwargs): return tfd.Uniform(low=0.0, high=np.inf, **kwargs)
def sample(self): component_mean = tfd.Uniform().sample( [self.num_components, self.var_dim]) return component_mean