SYMBOL INDEX (227 symbols across 20 files)

FILE: binary_vae_multilayer_per_layer.py
  function safe_log_prob (line 12) | def safe_log_prob(x, eps=1e-8):
  function safe_clip (line 16) | def safe_clip(x, eps=1e-8):
  function gs (line 20) | def gs(x):
  function softplus (line 24) | def softplus(x):
  function bernoulli_loglikelihood (line 38) | def bernoulli_loglikelihood(b, log_alpha):
  function bernoulli_loglikelihood_derivitive (line 42) | def bernoulli_loglikelihood_derivitive(b, log_alpha):
  function v_from_u (line 48) | def v_from_u(u, log_alpha, force_same=True):
  function reparameterize (line 67) | def reparameterize(log_alpha, noise, name=None):
  function concrete_relaxation (line 71) | def concrete_relaxation(log_alpha, noise, temp, name):
  function neg_elbo (line 76) | def neg_elbo(x, samples, log_alphas_inf, log_alphas_gen, prior, log=False):
  function linear_layer (line 104) | def linear_layer(x, num_latents, name, reuse):
  function nonlinear_layer (line 110) | def nonlinear_layer(x, num_latents, name, reuse):
  function inference_network (line 118) | def inference_network(x, mean, layer, num_layers, num_latents, name, reu...
  function layer_name (line 138) | def layer_name(l):
  function Q_name (line 142) | def Q_name(l):
  function generator_network (line 145) | def generator_network(samples, output_bias, layer, num_layers, num_laten...
  function Q_func (line 167) | def Q_func(x, x_mean, z, bs, name, reuse, depth):
  function create_log_temp (line 184) | def create_log_temp(num):
  function create_eta (line 193) | def create_eta(num):
  class BSampler (line 202) | class BSampler:
    method __init__ (line 203) | def __init__(self, u, name):
    method sample (line 206) | def sample(self, log_alpha, l):
  class ZSampler (line 212) | class ZSampler:
    method __init__ (line 213) | def __init__(self, u, name):
    method sample (line 216) | def sample(self, log_alpha, l):
  class SIGZSampler (line 221) | class SIGZSampler:
    method __init__ (line 222) | def __init__(self, u, temp, name):
    method sample (line 226) | def sample(self, log_alpha, l):
  function log_image (line 231) | def log_image(im_vec, name):
  function get_variables (line 239) | def get_variables(tag, arr=None):
  function main (line 246) | def main(relaxation=None, learn_prior=True, max_iters=None,

FILE: datasets.py
  function load_mnist (line 6) | def load_mnist(data_file="/u/wgrathwohl/relaxed-rebar/data/mnist_salakhu...
  function load_omniglot (line 12) | def load_omniglot(data_file='/u/wgrathwohl/relaxed-rebar/data/omniglot_0...

FILE: mnist_vae.py
  function encoder (line 6) | def encoder(x):
  function decoder (line 15) | def decoder(b):
  function Q_func (line 21) | def Q_func(z):
  function to_vec (line 46) | def to_vec(t):
  function from_vec (line 48) | def from_vec(t):
  function loss (line 58) | def loss(b):

FILE: pytorch_test.py
  function _parse_args (line 7) | def _parse_args(args):
  function test (line 17) | def test(args=None):

FILE: pytorch_toy.py
  class QFunc (line 11) | class QFunc(torch.nn.Module):
    method __init__ (line 14) | def __init__(self, num_latents, hidden_size=10):
    method forward (line 20) | def forward(self, z):
  function loss_func (line 29) | def loss_func(b, t):
  function _parse_args (line 33) | def _parse_args(args):
  function reinforce (line 49) | def reinforce(f_b, b, logits, **kwargs):
  function _get_z_tilde (line 57) | def _get_z_tilde(logits, b, v):
  function rebar (line 64) | def rebar(
  function relax (line 89) | def relax(f_b, b, logits, z, v, log_temp, q_func, **kwargs):
  function run_toy_example (line 112) | def run_toy_example(args=None):

FILE: rebar_baseline/datasets.py
  function load_data (line 32) | def load_data(hparams):
  function read_MNIST (line 42) | def read_MNIST(binarize=False):
  function read_omniglot (line 63) | def read_omniglot(binarize=False):

FILE: rebar_baseline/download_data.py
  function load_mnist_float (line 38) | def load_mnist_float(local_filename):

FILE: rebar_baseline/logger.py
  class Logger (line 22) | class Logger:
    method __init__ (line 23) | def __init__(self):
    method log (line 26) | def log(self, key, value):
    method flush (line 29) | def flush(self):

FILE: rebar_baseline/rebar.py
  class SBN (line 39) | class SBN(object):  # REINFORCE
    method __init__ (line 41) | def __init__(self,
    method initialize (line 88) | def initialize(self, sess):
    method _create_eta (line 91) | def _create_eta(self, shape=[], collection='CV'):
    method _create_baseline (line 95) | def _create_baseline(self, n_output=1, n_hidden=100,
    method _create_transformation (line 120) | def _create_transformation(self, input, n_output, reuse, scope_prefix):
    method _recognition_network (line 163) | def _recognition_network(self, sampler=None, log_likelihood_func=None):
    method _generator_network (line 232) | def _generator_network(self, samples, logQ, log_likelihood_func=None):
    method _q_func (line 305) | def _q_func(self, samples, collection='Q_FUNC'):
    method _create_loss (line 360) | def _create_loss(self):
    method _reshape (line 377) | def _reshape(self, t):
    method compute_tensor_variance (line 382) | def compute_tensor_variance(self, t):
    method _create_train_op (line 397) | def _create_train_op(self, grads_and_vars, extra_grads_and_vars=[]):
    method _create_network (line 443) | def _create_network(self):
    method partial_fit (line 456) | def partial_fit(self, X, n_samples=1):
    method partial_grad (line 466) | def partial_grad(self, X, n_samples=1):
    method partial_eval (line 472) | def partial_eval(self, X, n_samples=5):
    method _mean_sample (line 491) | def _mean_sample(self, log_alpha, _, layer):
    method _generate_randomness (line 500) | def _generate_randomness(self):
    method _u_to_v (line 505) | def _u_to_v(self, log_alpha, u, eps = 1e-8):
    method _random_sample (line 524) | def _random_sample(self, log_alpha, u, layer):
    method _random_sample_soft (line 540) | def _random_sample_soft(self, log_alpha, u, layer, temperature=None):
    method _random_sample_soft_v (line 560) | def _random_sample_soft_v(self, log_alpha, _, layer, temperature=None):
    method get_gumbel_gradient (line 566) | def get_gumbel_gradient(self):
    method _random_sample_switch (line 581) | def _random_sample_switch(self, log_alpha, u, layer, switch_layer, tem...
    method _random_sample_switch_v (line 592) | def _random_sample_switch_v(self, log_alpha, u, layer, switch_layer, t...
    method get_nvil_gradient (line 607) | def get_nvil_gradient(self):
    method get_simple_muprop_gradient (line 632) | def get_simple_muprop_gradient(self):
    method get_muprop_gradient (line 665) | def get_muprop_gradient(self):
    method _create_gumbel_control_variate (line 726) | def _create_gumbel_control_variate(self, logQHard, temperature=None):
    method _create_relaxed_gumbel_control_variate (line 754) | def _create_relaxed_gumbel_control_variate(self, logQHard, temperature...
    method _create_gumbel_control_variate_quadratic (line 786) | def _create_gumbel_control_variate_quadratic(self, logQHard, temperatu...
    method _create_relaxed_gumbel_control_variate_quadratic (line 815) | def _create_relaxed_gumbel_control_variate_quadratic(self, logQHard, t...
    method _create_hard_elbo (line 848) | def _create_hard_elbo(self):
    method multiply_by_eta (line 861) | def multiply_by_eta(self, h_grads, eta):
    method multiply_by_eta_per_layer (line 876) | def multiply_by_eta_per_layer(self, h_grads, eta):
    method multiply_by_eta_per_unit (line 891) | def multiply_by_eta_per_unit(self, h_grads, eta):
    method get_relaxed_dynamic_rebar_gradient (line 910) | def get_relaxed_dynamic_rebar_gradient(self):
    method get_dynamic_rebar_gradient (line 981) | def get_dynamic_rebar_gradient(self):
    method get_rebar_gradient (line 1042) | def get_rebar_gradient(self):
  class SBNSimpleMuProp (line 1072) | class SBNSimpleMuProp(SBN):
    method _create_loss (line 1073) | def _create_loss(self):
    method _create_network (line 1083) | def _create_network(self):
  class SBNMuProp (line 1092) | class SBNMuProp(SBN):
    method _create_loss (line 1093) | def _create_loss(self):
    method _create_network (line 1103) | def _create_network(self):
  class SBNNVIL (line 1113) | class SBNNVIL(SBN):
    method _create_loss (line 1114) | def _create_loss(self):
    method _create_network (line 1123) | def _create_network(self):
  class SBNRebar (line 1133) | class SBNRebar(SBN):
    method _create_loss (line 1134) | def _create_loss(self):
    method _create_network (line 1144) | def _create_network(self):
  class SBNDynamicRebar (line 1158) | class SBNDynamicRebar(SBN):
    method _create_loss (line 1159) | def _create_loss(self):
    method _create_network (line 1170) | def _create_network(self):
  class SBNRelaxedDynamicRebar (line 1185) | class SBNRelaxedDynamicRebar(SBN):
    method _create_loss (line 1186) | def _create_loss(self):
    method _create_network (line 1197) | def _create_network(self):
  class SBNTrackGradVariances (line 1219) | class SBNTrackGradVariances(SBN):
    method compute_gradient_moments (line 1221) | def compute_gradient_moments(self, grads_and_vars):
    method _create_loss (line 1228) | def _create_loss(self):
    method _create_network (line 1277) | def _create_network(self):
  class SBNGumbel (line 1292) | class SBNGumbel(SBN):
    method _random_sample_soft (line 1293) | def _random_sample_soft(self, log_alpha, u, layer, temperature=None):
    method _create_loss (line 1313) | def _create_loss(self):

FILE: rebar_baseline/rebar_train.py
  function manual_scalar_summary (line 47) | def manual_scalar_summary(name, value):
  function eval (line 52) | def eval(sbn, eval_xs, n_samples=100, batch_size=5):
  function train (line 63) | def train(sbn, train_xs, valid_xs, test_xs, training_steps, debug=False):
  function main (line 184) | def main():

FILE: rebar_baseline/utils.py
  function exp_moving_average (line 32) | def exp_moving_average(x, alpha=0.9):
  function sanitize (line 43) | def sanitize(s):
  function softplus (line 49) | def softplus(x):
  function safe_log_prob (line 61) | def safe_log_prob(x, eps=1e-8):
  function rms (line 64) | def rms(x):
  function center (line 67) | def center(x):
  function vectorize (line 71) | def vectorize(grads_and_vars, set_none_to_zero=False, skip_none=False):
  function add_grads_and_vars (line 80) | def add_grads_and_vars(a, b):
  function binary_log_likelihood (line 93) | def binary_log_likelihood(y, log_y_hat):
  function cov (line 107) | def cov(a, b):
  function corr (line 115) | def corr(a, b):
  function logSumExp (line 118) | def logSumExp(t, axis=0, keep_dims = False):

FILE: rebar_tf.py
  function safe_log_prob (line 12) | def safe_log_prob(x, eps=1e-8):
  function safe_clip (line 15) | def safe_clip(x, eps=1e-8):
  function gs (line 19) | def gs(x):
  function softplus (line 23) | def softplus(x):
  function bernoulli_loglikelihood (line 36) | def bernoulli_loglikelihood(b, log_alpha):
  function bernoulli_loglikelihood_derivitive (line 40) | def bernoulli_loglikelihood_derivitive(b, log_alpha):
  class REBAROptimizer (line 46) | class REBAROptimizer(object):
    method __init__ (line 47) | def __init__(self, sess, loss, log_alpha=None, dim=None, name="REBAR",...
    method _create_model_parameters (line 68) | def _create_model_parameters(self):
    method _create_reparam_variables (line 110) | def _create_reparam_variables(self, eps=1e-8):
    method _create_loss_evaluations (line 139) | def _create_loss_evaluations(self):
    method _create_gradvars (line 155) | def _create_gradvars(self):
    method train (line 192) | def train(self, n_steps=10000):
  class RelaxedREBAROptimizer (line 207) | class RelaxedREBAROptimizer(REBAROptimizer):
    method __init__ (line 208) | def __init__(self, sess, loss, q_func, log_alpha=None, dim=None, name=...
    method _create_loss_evaluations (line 220) | def _create_loss_evaluations(self):
    method _Q_gradvars (line 246) | def _Q_gradvars(self):
  function loss (line 267) | def loss(b):

FILE: rebar_toy.py
  function safe_log_prob (line 33) | def safe_log_prob(x, eps=1e-8):
  function safe_clip (line 37) | def safe_clip(x, eps=1e-8):
  function gs (line 41) | def gs(x):
  function softplus (line 45) | def softplus(x):
  function logistic_loglikelihood (line 58) | def logistic_loglikelihood(z, loc, scale=1):
  function bernoulli_loglikelihood (line 62) | def bernoulli_loglikelihood(b, log_alpha):
  function bernoulli_loglikelihood_derivitive (line 66) | def bernoulli_loglikelihood_derivitive(b, log_alpha):
  function v_from_u (line 72) | def v_from_u(u, log_alpha, force_same=True, b=None, v_prime=None):
  function reparameterize (line 93) | def reparameterize(log_alpha, noise):
  function concrete_relaxation (line 97) | def concrete_relaxation(z, temp):
  function assert_same_shapes (line 101) | def assert_same_shapes(*args):
  function neg_elbo (line 107) | def neg_elbo(x, b, log_alpha, pred_x_log_alpha):
  function Q_func (line 115) | def Q_func(z):
  function loss_func (line 128) | def loss_func(b, t):
  function main (line 132) | def main(t=0.499, rand_seed=42, use_reinforce=False, relaxed=False, visu...

FILE: relax-autograd/demo_concrete.py
  function objective (line 21) | def objective(b):
  function mc_objective_and_var (line 24) | def mc_objective_and_var(combined_params, t):
  function combined_obj (line 33) | def combined_obj(combined_params, t):
  function callback (line 48) | def callback(combined_params, t, combined_grads):

FILE: relax-autograd/demo_rebar.py
  function objective (line 19) | def objective(b):
  function mc_objective_and_var (line 22) | def mc_objective_and_var(combined_params, t):
  function combined_grad (line 30) | def combined_grad(combined_params, t):
  function callback (line 45) | def callback(combined_params, t, combined_gradient):

FILE: relax-autograd/demo_reinforce.py
  function objective (line 21) | def objective(b):
  function mc_objective_and_var (line 24) | def mc_objective_and_var(params, t):
  function obj_grads (line 33) | def obj_grads(params, t):
  function callback (line 46) | def callback(params, t, gradient):

FILE: relax-autograd/demo_relax.py
  function make_one_d (line 12) | def make_one_d(f, d, full_d_input):
  function map_and_stack (line 19) | def map_and_stack(f):
  function objective (line 35) | def objective(b):
  function mc_objective_and_var (line 38) | def mc_objective_and_var(combined_params, t):
  function combined_grad (line 46) | def combined_grad(combined_params, t):
  function callback (line 63) | def callback(combined_params, t, combined_gradient):

FILE: relax-autograd/relax.py
  function heaviside (line 8) | def heaviside(z):
  function softmax (line 11) | def softmax(z, log_temperature):
  function logistic_sample (line 15) | def logistic_sample(noise, mu=0, sigma=1):
  function logistic_logpdf (line 18) | def logistic_logpdf(x, mu=0, scale=1):
  function bernoulli_sample (line 22) | def bernoulli_sample(logit_theta, noise):
  function relaxed_bernoulli_sample (line 25) | def relaxed_bernoulli_sample(logit_theta, noise, log_temperature):
  function conditional_noise (line 28) | def conditional_noise(logit_theta, samples, noise):
  function bernoulli_logprob (line 33) | def bernoulli_logprob(logit_theta, targets):
  function reinforce (line 40) | def reinforce(params, noise, func_vals):
  function concrete (line 47) | def concrete(params, log_temperature, noise, f):
  function rebar (line 54) | def rebar(params, est_params, noise_u, noise_v, f):
  function rebar_all (line 68) | def rebar_all(params, est_params, noise_u, noise_v, f):
  function init_nn_params (line 79) | def init_nn_params(scale, layer_sizes, rs=npr.RandomState(0)):
  function nn_predict (line 87) | def nn_predict(params, inputs):
  function relax (line 93) | def relax(params, est_params, noise_u, noise_v, func_vals):
  function relax_all (line 109) | def relax_all(params, est_params, noise_u, noise_v, f):

FILE: relax-autograd/tests.py
  function objective (line 20) | def objective(b):
  function expected_objective (line 23) | def expected_objective(params):
  function mc (line 28) | def mc(params, estimator):  # Simple Monte Carlo
  function var_naive (line 45) | def var_naive(est_params, method):
  function var_grads (line 53) | def var_grads(est_params, method):

FILE: toy.py
  function safe_log_prob (line 19) | def safe_log_prob(x, eps=1e-8):
  function safe_clip (line 23) | def safe_clip(x, eps=1e-8):
  function gs (line 27) | def gs(x):
  function softplus (line 31) | def softplus(x):
  function logistic_loglikelihood (line 44) | def logistic_loglikelihood(z, loc, scale=1):
  function bernoulli_loglikelihood (line 48) | def bernoulli_loglikelihood(b, log_alpha):
  function bernoulli_loglikelihood_derivitive (line 52) | def bernoulli_loglikelihood_derivitive(b, log_alpha):
  function v_from_u (line 58) | def v_from_u(u, log_alpha, force_same=True, b=None, v_prime=None):
  function reparameterize (line 79) | def reparameterize(log_alpha, noise):
  function concrete_relaxation (line 83) | def concrete_relaxation(z, temp):
  function assert_same_shapes (line 87) | def assert_same_shapes(*args):
  function neg_elbo (line 93) | def neg_elbo(x, b, log_alpha, pred_x_log_alpha):
  function Q_func (line 103) | def Q_func(z):
  function loss_func (line 109) | def loss_func(b, t):
  function main (line 113) | def main(t=0.499, rand_seed=42, use_reinforce=False, relaxed=False,