def bayesianNN(observed, x, n_x, layer_sizes, n_particles): with zs.BayesianNet(observed=observed) as model: ws = [] for i, (n_in, n_out) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): w_mu = tf.zeros([1, n_out, n_in + 1]) ws.append( zs.Normal('w' + str(i), w_mu, std=1., n_samples=n_particles, group_ndims=2)) # forward ly_x = tf.expand_dims( tf.tile(tf.expand_dims(x, 0), [n_particles, 1, 1]), 3) for i in range(len(ws)): w = tf.tile(ws[i], [1, tf.shape(x)[0], 1, 1]) ly_x = tf.concat( [ly_x, tf.ones([n_particles, tf.shape(x)[0], 1, 1])], 2) ly_x = tf.matmul(w, ly_x) / tf.sqrt(tf.to_float(tf.shape(ly_x)[2])) if i < len(ws) - 1: ly_x = tf.nn.relu(ly_x) y_mean = tf.squeeze(ly_x, [2, 3]) y_logstd = tf.get_variable('y_logstd', shape=[], initializer=tf.constant_initializer(0.)) y = zs.Normal('y', y_mean, logstd=y_logstd) return model, y_mean
def vae(observed, n, n_z, n_particles): with zs.BayesianNet(observed=observed) as model: z_mean = tf.zeros([n, n_z]) z = zs.Normal('z', z_mean, std=1., n_samples=n_particles, group_ndims=1) lx_z = layers.fully_connected(z, num_outputs=ngf * 8 * 4 * 4, activation_fn=None) lx_z = tf.reshape(lx_z, [-1, 4, 4, ngf * 8]) lx_z = layers.conv2d_transpose(lx_z, ngf * 4, 5, stride=2) lx_z = layers.conv2d_transpose(lx_z, ngf * 2, 5, stride=2) lx_z = layers.conv2d_transpose(lx_z, ngf, 5, stride=2) lx_z = layers.conv2d_transpose(lx_z, 3, 5, stride=2, activation_fn=tf.nn.sigmoid) x_mean = tf.reshape(lx_z, [-1, n, 64, 64, 3]) x_logstd = tf.get_variable("h_logstd", shape=[64, 64, 3], dtype=tf.float32, initializer=tf.constant_initializer(0.)) x = zs.Normal('x', x_mean, logstd=x_logstd, group_ndims=3) return model, x_mean
def p_net(observed,input_data,market_encode,prev_z,prob,gen_mode = False): with zs.BayesianNet(observed=observed) as decoder: cat = tf.concat([prev_z, market_encode, input_data],1) h_z = tf.layers.dropout(tf.layers.dense(inputs=cat,units=config.LATENT_SIZE,activation = tf.nn.tanh,name='h_z_prior', reuse=tf.AUTO_REUSE),rate = prob) z_mean = tf.layers.dropout(tf.layers.dense(inputs=h_z,units=config.LATENT_SIZE,activation = None,name='z_mu_prior', reuse = tf.AUTO_REUSE),rate = prob) z_logstd = tf.layers.dropout(tf.layers.dense(inputs=h_z,units=config.LATENT_SIZE,activation = None,name='z_delta_prior', reuse = tf.AUTO_REUSE),rate = prob) z = zs.Normal(name='z',mean=z_mean,logstd = z_logstd,group_ndims=2,reuse=tf.AUTO_REUSE) p_z = zs.Normal(name = 'pz', mean=z_mean,logstd = z_logstd,group_ndims=2,reuse=tf.AUTO_REUSE) if gen_mode: cat = tf.concat([input_data, market_encode, z_mean],1) else:#inference cat = tf.concat([input_data, market_encode, z],1) g = tf.layers.dropout(tf.layers.dense(inputs=cat, units=config.LATENT_SIZE, name='g', activation=tf.nn.tanh, reuse = tf.AUTO_REUSE),rate = prob) y = tf.layers.dropout(tf.layers.dense(inputs=g, units=2, activation=None,name='y_hat',reuse = tf.AUTO_REUSE), rate = prob) return y,g,p_z
def lntm(observed, n_chains, D, K, V, eta_mean, eta_logstd): with zs.BayesianNet(observed=observed) as model: eta_mean = tf.tile(tf.expand_dims(eta_mean, 0), [D, 1]) eta = zs.Normal('eta', eta_mean, logstd=eta_logstd, n_samples=n_chains, group_ndims=1) beta = zs.Normal('beta', tf.zeros([K, V]), logstd=log_delta, group_ndims=1) return model
def model_func(observed): with zs.BayesianNet(observed) as net: z = zs.Normal('z', mean=tf.zeros([3]), std=tf.ones([3]), n_samples=n_z) x = zs.Normal('x', mean=z, std=tf.ones([3])) return net
def vae(observed, n, n_x, n_z, n_samples, is_training): with zs.BayesianNet(observed=observed) as model: normalizer_params = { 'is_training': is_training, 'updates_collections': None } z_mean = tf.zeros([n, n_z]) # the mean of z is the zero vector z_std = 1. # the covariance of z is the identity matrix, here a scalar is sufficient because it will be broadcasted to a vector and then used as the diagonal of the covariance matrix in zhusuan ''' TODO1: sampling z using the Gaussian distribution of zhusuan > given input - z_mean, z_std, n_samples - set group_event_ndims as 1 > e.g. - x = zs.Bernoulli('x', mu, group_event_ndims=1) ''' z = zs.Normal('z', z_mean, std=z_std, n_samples=n_samples, group_event_ndims=1) lx_z = layers.fully_connected( z, 500, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params ) # a mlp layer of 500 hidden units with z as the input ''' TODO2: add one more mlp layer with 500 hidden units > given input - lx_z_1, size of hidden units, normalizer_params - add batch_norm as the normalizer_fn > e.g. see the above line ''' lx_z = layers.fully_connected(lx_z, 500, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) x_mean = layers.fully_connected(lx_z, n_x, activation_fn=None) # compute the mean x_logstd = layers.fully_connected( lx_z, n_x, activation_fn=None) # compute the log std x = zs.Normal('x', x_mean, logstd=x_logstd, n_samples=n_samples, group_event_ndims=1) return model, x_mean
def lntm(observed, D, K, V, eta_mean, eta_logstd): with zs.BayesianNet(observed=observed) as model: eta = zs.Normal('eta', tf.tile(tf.expand_dims(eta_mean, 0), [D, 1]), logstd=tf.tile(tf.expand_dims(eta_logstd, 0), [D, 1]), group_event_ndims=1) beta = zs.Normal('beta', tf.zeros([K, V]), logstd=tf.ones([K, V]) * log_delta, group_event_ndims=1) return model
def lntm(observed, n_chains, D, K, V, eta_mean, eta_logstd): with zs.BayesianNet(observed=observed) as model: D_multiple = tf.stack([D, 1]) n_chains_multiple = tf.stack([n_chains, 1, 1]) eta = zs.Normal('eta', tf.tile(tf.expand_dims( tf.tile(tf.expand_dims(eta_mean, 0), D_multiple), 0), n_chains_multiple), logstd=eta_logstd, group_ndims=1) beta = zs.Normal('beta', tf.zeros([K, V]), logstd=log_delta, group_ndims=1) return model
def bayesianNN(observed, x, n_x, layer_sizes, n_particles, batchsize, segment_length): with zs.BayesianNet(observed=observed) as model: ws = [] for i, (n_in, n_out) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): w_mu = tf.zeros([1, n_out, n_in + 1]) ws.append( zs.Normal('w' + str(i), w_mu, std=1., n_samples=n_particles, group_ndims=2)) # forward # replicate input to sample many networks ly_x = tf.expand_dims( tf.tile(tf.expand_dims(x, 0), [n_particles, 1, 1]), 3) for i in range(len(ws)): # tile weights per batch and frame w = tf.tile(ws[i], [1, tf.shape(x)[0], 1, 1]) # add bias ly_x = tf.concat( [ly_x, tf.ones([n_particles, tf.shape(x)[0], 1, 1])], 2) # forward pass ly_x = tf.matmul(w, ly_x) / tf.sqrt(tf.to_float(tf.shape(ly_x)[2])) # add relu activation if not last layer if i < len(ws) - 1: ly_x = tf.nn.relu(ly_x) # y_mean = fNN(x, W) reward_mean = tf.squeeze(ly_x, [2, 3]) # reshape rewards to sum up segments segment_rewards = tf.reshape(reward_mean, (-1, batchsize, segment_length)) segment_rewards = tf.reduce_sum(segment_rewards, axis=2) # y ~ N(y|y_mean, y_logstd) : noise is added to the output to get a tractable likelihood segment_logstd = tf.get_variable( 'segment_logstd', shape=[], initializer=tf.constant_initializer(0.)) _ = zs.Normal('segment_rewards', segment_rewards, logstd=segment_logstd) return model, reward_mean, None, segment_rewards
def var_dropout(observed, x, n, net_size, n_particles, is_training): with zs.BayesianNet(observed=observed) as model: h = x normalizer_params = { 'is_training': is_training, 'updates_collections': None } for i, [n_in, n_out] in enumerate(zip(net_size[:-1], net_size[1:])): eps_mean = tf.zeros([n, n_in]) # Adding noise to Weights eps = zs.Normal('layer' + str(i) + '/eps', eps_mean, std=1., n_samples=n_particles, group_ndims=1) h = layers.fully_connected(h * eps, n_out, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) if i < len(net_size) - 2: h = tf.nn.relu(h) y = zs.Categorical('y', h, group_ndims=0) return model, h
def q_net(x, n_xl, n_z, n_particles, is_training): with zs.BayesianNet() as variational: normalizer_params = { 'is_training': is_training, 'updates_collections': None } lz_x = tf.reshape(tf.to_float(x), [-1, n_xl, n_xl, 1]) lz_x = layers.conv2d(lz_x, 32, kernel_size=5, stride=2, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lz_x = layers.conv2d(lz_x, 64, kernel_size=5, stride=2, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lz_x = layers.conv2d(lz_x, 128, kernel_size=5, padding='VALID', normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lz_x = layers.dropout(lz_x, keep_prob=0.9, is_training=is_training) lz_x = tf.reshape(lz_x, [-1, 128 * 3 * 3]) lz_mean = layers.fully_connected(lz_x, n_z, activation_fn=None) lz_logstd = layers.fully_connected(lz_x, n_z, activation_fn=None) z = zs.Normal('z', lz_mean, lz_logstd, n_samples=n_particles, group_event_ndims=1) return variational
def __init__(self, obs_shape, act_shape, observed, n_particles, segment_length, batchsize, h_size=64): self.n_particles = n_particles self.batchsize = batchsize self.segment_length = segment_length with zs.BayesianNet(observed=observed) as model: input_dim = np.prod(obs_shape) + np.prod(act_shape) layer_sizes = [input_dim] + [64] + [1] self.w_names = ['w' + str(i) for i in range(len(layer_sizes) - 1)] self.ws = [] for i, (n_in, n_out) in enumerate(zip(layer_sizes[:-1], layer_sizes[1:])): w_mu = tf.zeros([1, n_out, n_in + 1]) self.ws.append( zs.Normal('w' + str(i), w_mu, std=1., n_samples=n_particles, group_ndims=2)) self.model = model
def vae(observed, n, dim_x, dim_z, n_particles): '''decoder: z-->x''' with zs.BayesianNet(observed=observed) as model: pai = tf.get_variable('pai', shape=[dim_z], dtype=tf.float32, trainable=True, initializer=tf.constant_initializer(1.0), #tf.random_uniform_initializer(), #tf.ones([dim_z]), ) n_pai = tf.tile(tf.expand_dims(pai, 0), [n, 1]) z = zs.OnehotCategorical('z', logits=n_pai, dtype=tf.float32, n_samples=n_particles #group_event_ndims=1 ) # zhusuan.model.stochastic.OnehotCategorical print('-'*10, 'z:', z.tensor.get_shape().as_list()) # [n_particles, None, dim_z] mu = tf.get_variable('mu', shape=[dim_z, dim_x], dtype=tf.float32, initializer=tf.random_uniform_initializer(0, 1)) log_sigma = tf.get_variable('log_sigma', shape=[dim_z, dim_x], dtype=tf.float32, initializer=tf.random_uniform_initializer(-3, -2) ) # tf.random_normal_initializer(-3, 0.5)) #tf.contrib.layers.xavier_initializer()) x_mean = tf.reshape(tf.matmul(tf.reshape(z, [-1, dim_z]), mu), [n_particles, n, dim_x]) # [n_particles, None, dim_x] x_logstd = tf.reshape(tf.matmul(tf.reshape(z, [-1, dim_z]), log_sigma), [n_particles, n, dim_x]) # print('x_mean:', x_mean.get_shape().as_list()) # print('x_logstd:', x_logstd.get_shape().as_list()) x = zs.Normal('x', mean=x_mean, logstd=x_logstd, group_event_ndims=1) # print('x:', x.tensor.get_shape().as_list()) return model, x.tensor, z.tensor
def forward(self, mean): mean = tf.squeeze(mean, [-1]) prec = self.ps(tf.shape(mean)[0]) prec = tf.stop_gradient(prec) y_logstd = -0.5 * tf.log(prec) y = zs.Normal('y', mean, logstd=y_logstd * tf.ones_like(mean)) return y
def vae_conv(observed, n, n_x, n_z, n_particles, is_training): with zs.BayesianNet(observed=observed) as model: normalizer_params = {'is_training': is_training, 'updates_collections': None} z_mean = tf.zeros([n, n_z]) z = zs.Normal('z', z_mean, std=1., n_samples=n_particles, group_event_ndims=1) lx_z = tf.reshape(z, [-1, 1, 1, n_z]) lx_z = layers.conv2d_transpose( lx_z, 128, kernel_size=3, padding='VALID', normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lx_z = layers.conv2d_transpose( lx_z, 64, kernel_size=5, padding='VALID', normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lx_z = layers.conv2d_transpose( lx_z, 32, kernel_size=5, stride=2, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params) lx_z = layers.conv2d_transpose( lx_z, 1, kernel_size=5, stride=2, activation_fn=None) x_logits = tf.reshape(lx_z, [n_particles, n, -1]) x = zs.Bernoulli('x', x_logits, group_event_ndims=1) return model
def q_net(observed, x, n_z, n_samples, is_training): with zs.BayesianNet(observed=observed) as variational: normalizer_params = {"is_training": is_training, "updates_collections": None} x = tf.to_float(x) # for computation issue """ TODO3: add two more mlp layers with 500 hidden units > given input - x, size of hidden units, normalizer_params - add batch_norm as the normalizer_fn > e.g. see the generative model """ lz_x_1 = layers.fully_connected( x, 500, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params ) # a mlp layer of 500 hidden units with z as the input lz_x_2 = layers.fully_connected( lz_x_1, 500, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params ) # a mlp layer of 500 hidden units with z as the input z_mean = layers.fully_connected(lz_x_2, n_z, activation_fn=None) # compute the mean z_logstd = layers.fully_connected(lz_x_2, n_z, activation_fn=None) # compute the log std """ TODO4: sampling z using the Gaussian distribution of zhusuan > given input - z_mean, z_logstd (note that it is not std), n_samples - set group_event_ndims as 1 > e.g. - x = zs.Bernoulli('x', mu, group_event_ndims=1) """ z = zs.Normal("z", z_mean, logstd=z_logstd, group_ndims=1) return variational
def q(observed, n, net_size, n_particles): # Build the variational posterior distribution. # We assume it is factorized with zs.BayesianNet(observed=observed) as variational: ws = [] for i, [n_in, n_out] in enumerate(zip(net_size[:-1], net_size[1:])): with tf.variable_scope('layer' + str(i)): logit_alpha = tf.get_variable( 'logit_alpha', [n_in], initializer=tf.constant_initializer(0.1)) alpha = tf.nn.sigmoid(logit_alpha) alpha = tf.tile(tf.expand_dims(alpha, 0), [n, 1]) # eps = zs.Normal('layer' + str(i) + '/eps', # 1., logstd=0.5 * tf.log(alpha + 1e-6), # n_samples=n_particles, group_ndims=1) w_mean = tf.get_variable('w_mean_' + str(i), shape=[n_in], initializer=tf.constant_initializer(0.)) w_logstd = tf.get_variable('w_logstd_' + str(i), shape=[n_in], initializer=tf.constant_initializer(0.)) w_mean = tf.tile(tf.expand_dims(w_mean, 0), [n, 1]) w_logstd = tf.tile(tf.expand_dims(w_logstd, 0), [n, 1]) ws.append( zs.Normal('layer' + str(i) + '/eps', w_mean, logstd=w_logstd, n_samples=n_particles, group_ndims=1)) return variational
def q_net(x, n_z): with zs.BayesianNet() as variational: lz_x = layers.fully_connected(tf.to_float(x), 500) lz_x = layers.fully_connected(lz_x, 500) z_mean = layers.fully_connected(lz_x, n_z, activation_fn=None) z_logstd = layers.fully_connected(lz_x, n_z, activation_fn=None) z = zs.Normal('z', z_mean, logstd=z_logstd, group_event_ndims=1) return variational
def q_net(x, n_h): with zs.BayesianNet() as qh: lz_x = layers.fully_connected(tf.to_float(x), 512) lz_x = layers.fully_connected(lz_x, 512) h_mean = layers.fully_connected(lz_x, n_h, activation_fn=None) h_logstd = layers.fully_connected(lz_x, n_h, activation_fn=None) h = zs.Normal('h', h_mean, logstd=h_logstd, group_ndims=1) return qh
def q_z_xy(self, captions, labels, lengths, images=None): """Calculate approximate posterior q(z|x, y, f(I)) Returns: model: zhusuan model object, can be used for getting probabilities """ if images is not None: self.images_fv = images with zs.BayesianNet() as model: # encoder and decoder have different embeddings but the same image features with tf.device("/cpu:0"): embedding = tf.get_variable( "enc_embeddings", [self.vocab_size, self.embed_size], dtype=tf.float32) vect_inputs = tf.nn.embedding_lookup(embedding, captions) with tf.name_scope(name="net") as scope1: cell_0 = make_rnn_cell( [self.lstm_hidden], base_cell=tf.contrib.rnn.LSTMCell) zero_state0 = cell_0.zero_state( batch_size=tf.shape(self.images_fv)[0], dtype=tf.float32) # run this cell to get initial state added_shape = self.embed_size + self.params.n_classes im_f = tf.layers.dense(self.images_fv, added_shape) _, initial_state0 = cell_0(im_f, zero_state0) # c = h = tf.layers.dense(self.images_fv, # self.params.decoder_hidden, # name='dec_init_map') # initial_state0 = (tf.nn.rnn_cell.LSTMStateTuple(c, h), ) # x, y y = tf.tile(tf.expand_dims(labels, 1), [1, tf.shape(vect_inputs)[1], 1]) vect_inputs = tf.concat([vect_inputs, tf.to_float(y)], 2) outputs, final_state = tf.nn.dynamic_rnn(cell_0, inputs=vect_inputs, sequence_length=lengths, initial_state=initial_state0, swap_memory=True, dtype=tf.float32, scope=scope1) # [batch_size, 2 * lstm_hidden_size] # final_state = ((c, h), ) final_state = final_state[0][1] lz_mean = layers.dense(inputs=final_state, units=self.latent_size, activation=None) lz_logstd = layers.dense(inputs=final_state, units=self.latent_size, activation=None) lz_std = tf.exp(lz_logstd) # define latent variable`s Stochastic Tensor # add mu_k, sigma_k, CVAe ag-cvae tm_list = [] # means tl_list = [] # log standard deviations z = zs.Normal('z', mean=lz_mean, std=lz_std, group_ndims=1, n_samples=self.z_samples) return model, tm_list, tl_list
def q_net_font(observed, x, is_training): with zs.BayesianNet(observed=observed) as encoder: normalizer_params = { 'is_training': is_training, 'updates_collections': None } x = tf.reshape(tf.to_float(x), [-1, n_xl, n_xl, 1]) ladder0 = layers.conv2d( x, ngf, 4, stride=2, activation_fn=lrelu, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params, weights_initializer=init_ops.RandomNormal(stddev=0.02)) ladder0 = layers.conv2d( ladder0, ngf * 2, 4, stride=2, activation_fn=lrelu, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params, weights_initializer=init_ops.RandomNormal(stddev=0.02)) ladder0 = layers.conv2d( ladder0, ngf * 4, 4, stride=2, activation_fn=lrelu, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params, weights_initializer=init_ops.RandomNormal(stddev=0.02)) ladder0 = layers.conv2d( ladder0, ngf * 8, 4, stride=2, activation_fn=lrelu, normalizer_fn=layers.batch_norm, normalizer_params=normalizer_params, weights_initializer=init_ops.RandomNormal(stddev=0.02)) ladder0 = layers.flatten(ladder0) font_mean = layers.fully_connected(ladder0, font_dim, activation_fn=tf.identity) font_std = layers.fully_connected(ladder0, font_dim, activation_fn=tf.sigmoid) z_font = zs.Normal('z_font', mean=font_mean, std=font_std, n_samples=1, group_event_ndims=1) return encoder, z_font
def vae(observed, n, n_x, n_z): with zs.BayesianNet(observed=observed) as model: z_mean = tf.zeros([n, n_z]) z = zs.Normal('z', z_mean, std=1., group_event_ndims=1) lx_z = layers.fully_connected(z, 500) lx_z = layers.fully_connected(lx_z, 500) x_logits = layers.fully_connected(lx_z, n_x, activation_fn=None) x = zs.Bernoulli('x', x_logits, group_event_ndims=1) return model, x_logits
def q_net(observed, x, n_z, n_particles): with zs.BayesianNet(observed=observed) as variational: lz_x = layers.fully_connected(tf.to_float(x), 500) lz_x = layers.fully_connected(lz_x, 500) lz_mean = layers.fully_connected(lz_x, n_z, activation_fn=None) lz_logstd = layers.fully_connected(lz_x, n_z, activation_fn=None) z = zs.Normal('z', lz_mean, logstd=lz_logstd, n_samples=n_particles, group_ndims=1) return variational
def mean_field_variational(n_particles): with zs.BayesianNet() as variational: z_mean, z_logstd = [], [] for i in range(2): z_mean.append(tf.Variable(-2.)) z_logstd.append(tf.Variable(-5.)) _ = zs.Normal('z' + str(i + 1), z_mean[i], z_logstd[i], n_samples=n_particles) return variational, z_mean, z_logstd
def zs_model(self, observed=None, n_x=None, n_z=None, is_reparameterized=None, z_group_ndims=1, x_group_ndims=1): if is_reparameterized is None: is_reparameterized = True with zs.BayesianNet(observed) as net: z = zs.Normal('z', mean=tf.zeros([BATCH_SIZE, Z_DIMS]), std=tf.ones([BATCH_SIZE, Z_DIMS]), is_reparameterized=is_reparameterized, n_samples=n_z, group_ndims=z_group_ndims) x_params = self.h_for_p_x(z) x = zs.Normal('x', mean=x_params['mean'], logstd=x_params['logstd'], n_samples=n_x, group_ndims=x_group_ndims) return net
def qz_xy(x, y, n_z, n_particles): with zs.BayesianNet() as variational: lz_xy = layers.fully_connected(tf.to_float(tf.concat([x, y], 1)), 500) lz_xy = layers.fully_connected(lz_xy, 500) lz_mean = layers.fully_connected(lz_xy, n_z, activation_fn=None) lz_logstd = layers.fully_connected(lz_xy, n_z, activation_fn=None) z = zs.Normal('z', lz_mean, logstd=lz_logstd, n_samples=n_particles, group_ndims=1) return variational
def lntm(observed, n_chains, n_docs, n_topics, n_vocab, eta_mean, eta_logstd): with zs.BayesianNet(observed=observed) as model: eta_mean = tf.tile(tf.expand_dims(eta_mean, 0), [n_docs, 1]) # eta/theta: Unnormalized/normalized document-topic matrix eta = zs.Normal('eta', eta_mean, logstd=eta_logstd, n_samples=n_chains, group_ndims=1) theta = tf.nn.softmax(eta) # beta/phi: Unnormalized/normalized topic-word matrix beta = zs.Normal('beta', tf.zeros([n_topics, n_vocab]), logstd=log_delta, group_ndims=1) phi = tf.nn.softmax(beta) # doc_word: Document-word matrix doc_word = tf.matmul(tf.reshape(theta, [-1, n_topics]), phi) doc_word = tf.reshape(doc_word, [n_chains, n_docs, n_vocab]) x = zs.UnnormalizedMultinomial('x', tf.log(doc_word), normalize_logits=False, dtype=tf.float32) return model
def gaussian(observed, n_x, stdev, n_particles): with zs.BayesianNet(observed=observed) as model: x_mean = tf.zeros([n_x]) x = zs.Normal('x', x_mean, std=stdev, n_samples=n_particles, group_ndims=1) return model
def unlabeled_proposal(x, n_y, n_z, n_particles): with zs.BayesianNet() as proposal: y_logits = qy_x(x, n_y) y = zs.OnehotCategorical('y', y_logits, n_samples=n_particles) x_tiled = tf.tile(tf.expand_dims(x, 0), [n_particles, 1, 1]) z_mean, z_logstd = qz_xy(x_tiled, y, n_z) z = zs.Normal('z', z_mean, logstd=z_logstd, group_ndims=1, is_reparameterized=False) return proposal
def qh_net(x, z, n_h): with zs.BayesianNet() as variational: lh_x = layers.fully_connected(tf.to_float(tf.concat([x, z], axis=1)), 500) lh_x = layers.fully_connected(lh_x, 500) h_mean = layers.fully_connected(lh_x, n_h, activation_fn=None) h_logstd = layers.fully_connected(lh_x, n_h, activation_fn=None) h = zs.Normal('h', h_mean, logstd=h_logstd, group_ndims=1) return variational