Code
stringlengths 103
85.9k
| Summary
sequencelengths 0
94
|
|---|---|
Please provide a description of the function:def load_config(self):
config = dict([(key, value) for key, value in iteritems(self.options)
if key in self.cfg.settings and value is not None])
for key, value in iteritems(config):
self.cfg.set(key.lower(), value) | [
"Loads the configuration."
] |
Please provide a description of the function:def ppo_base_v1():
hparams = common_hparams.basic_params1()
hparams.learning_rate_schedule = "constant"
hparams.learning_rate_constant = 1e-4
hparams.clip_grad_norm = 0.5
hparams.weight_decay = 0
# If set, extends the LR warmup to all epochs except the final one.
hparams.add_hparam("lr_decay_in_final_epoch", False)
hparams.add_hparam("init_mean_factor", 0.1)
hparams.add_hparam("init_logstd", 0.1)
hparams.add_hparam("policy_layers", (100, 100))
hparams.add_hparam("value_layers", (100, 100))
hparams.add_hparam("clipping_coef", 0.2)
hparams.add_hparam("gae_gamma", 0.99)
hparams.add_hparam("gae_lambda", 0.95)
hparams.add_hparam("entropy_loss_coef", 0.01)
hparams.add_hparam("value_loss_coef", 1)
hparams.add_hparam("optimization_epochs", 15)
hparams.add_hparam("epoch_length", 200)
hparams.add_hparam("epochs_num", 2000)
hparams.add_hparam("eval_every_epochs", 10)
hparams.add_hparam("save_models_every_epochs", 30)
hparams.add_hparam("optimization_batch_size", 50)
hparams.add_hparam("intrinsic_reward_scale", 0.)
hparams.add_hparam("logits_clip", 0.0)
hparams.add_hparam("dropout_ppo", 0.1)
hparams.add_hparam("effective_num_agents", None)
# TODO(afrozm): Clean this up, this is used in PPO learner to get modalities.
hparams.add_hparam("policy_problem_name", "dummy_policy_problem")
return hparams | [
"Set of hyperparameters."
] |
Please provide a description of the function:def ppo_atari_base():
hparams = ppo_discrete_action_base()
hparams.learning_rate_constant = 1e-4
hparams.epoch_length = 200
hparams.gae_gamma = 0.985
hparams.gae_lambda = 0.985
hparams.entropy_loss_coef = 0.003
hparams.value_loss_coef = 1
hparams.optimization_epochs = 3
hparams.epochs_num = 1000
hparams.policy_network = "feed_forward_cnn_small_categorical_policy"
hparams.clipping_coef = 0.2
hparams.optimization_batch_size = 20
hparams.clip_grad_norm = 0.5
return hparams | [
"Pong base parameters."
] |
Please provide a description of the function:def ppo_original_params():
hparams = ppo_atari_base()
hparams.learning_rate_constant = 2.5e-4
hparams.gae_gamma = 0.99
hparams.gae_lambda = 0.95
hparams.clipping_coef = 0.1
hparams.value_loss_coef = 1
hparams.entropy_loss_coef = 0.01
hparams.eval_every_epochs = 200
hparams.dropout_ppo = 0.1
# The parameters below are modified to accommodate short epoch_length (which
# is needed for model based rollouts).
hparams.epoch_length = 50
hparams.optimization_batch_size = 20
return hparams | [
"Parameters based on the original PPO paper."
] |
Please provide a description of the function:def ppo_original_world_model():
hparams = ppo_original_params()
hparams.policy_network = "next_frame_basic_deterministic"
hparams_keys = hparams.values().keys()
video_hparams = basic_deterministic_params.next_frame_basic_deterministic()
for (name, value) in six.iteritems(video_hparams.values()):
if name in hparams_keys:
hparams.set_hparam(name, value)
else:
hparams.add_hparam(name, value)
# Mostly to avoid decaying WM params when training the policy.
hparams.weight_decay = 0
return hparams | [
"Atari parameters with world model as policy."
] |
Please provide a description of the function:def ppo_tiny_world_model():
hparams = ppo_original_params()
hparams.policy_network = "next_frame_basic_deterministic"
hparams_keys = hparams.values().keys()
video_hparams = basic_deterministic_params.next_frame_tiny()
for (name, value) in six.iteritems(video_hparams.values()):
if name in hparams_keys:
hparams.set_hparam(name, value)
else:
hparams.add_hparam(name, value)
hparams.weight_decay = 0
return hparams | [
"Atari parameters with world model as policy."
] |
Please provide a description of the function:def ppo_original_world_model_stochastic_discrete():
hparams = ppo_original_params()
hparams.policy_network = "next_frame_basic_stochastic_discrete"
hparams_keys = hparams.values().keys()
video_hparams = basic_stochastic.next_frame_basic_stochastic_discrete()
for (name, value) in six.iteritems(video_hparams.values()):
if name in hparams_keys:
hparams.set_hparam(name, value)
else:
hparams.add_hparam(name, value)
# To avoid OOM. Probably way to small.
hparams.optimization_batch_size = 1
hparams.weight_decay = 0
return hparams | [
"Atari parameters with stochastic discrete world model as policy."
] |
Please provide a description of the function:def make_simulated_env_fn(**env_kwargs):
def env_fn(in_graph):
class_ = SimulatedBatchEnv if in_graph else SimulatedBatchGymEnv
return class_(**env_kwargs)
return env_fn | [
"Returns a function creating a simulated env, in or out of graph.\n\n Args:\n **env_kwargs: kwargs to pass to the simulated env constructor.\n\n Returns:\n Function in_graph -> env.\n "
] |
Please provide a description of the function:def make_simulated_env_kwargs(real_env, hparams, **extra_kwargs):
objs_and_attrs = [
(real_env, [
"reward_range", "observation_space", "action_space", "frame_height",
"frame_width"
]),
(hparams, ["frame_stack_size", "intrinsic_reward_scale"])
]
kwargs = {
attr: getattr(obj, attr) # pylint: disable=g-complex-comprehension
for (obj, attrs) in objs_and_attrs for attr in attrs
}
kwargs["model_name"] = hparams.generative_model
kwargs["model_hparams"] = trainer_lib.create_hparams(
hparams.generative_model_params
)
if hparams.wm_policy_param_sharing:
kwargs["model_hparams"].optimizer_zero_grads = True
kwargs.update(extra_kwargs)
return kwargs | [
"Extracts simulated env kwargs from real_env and loop hparams."
] |
Please provide a description of the function:def get_policy(observations, hparams, action_space):
if not isinstance(action_space, gym.spaces.Discrete):
raise ValueError("Expecting discrete action space.")
obs_shape = common_layers.shape_list(observations)
(frame_height, frame_width) = obs_shape[2:4]
# TODO(afrozm): We have these dummy problems mainly for hparams, so cleanup
# when possible and do this properly.
if hparams.policy_problem_name == "dummy_policy_problem_ttt":
tf.logging.info("Using DummyPolicyProblemTTT for the policy.")
policy_problem = tic_tac_toe_env.DummyPolicyProblemTTT()
else:
tf.logging.info("Using DummyPolicyProblem for the policy.")
policy_problem = DummyPolicyProblem(action_space, frame_height, frame_width)
trainer_lib.add_problem_hparams(hparams, policy_problem)
hparams.force_full_predict = True
model = registry.model(hparams.policy_network)(
hparams, tf.estimator.ModeKeys.TRAIN
)
try:
num_target_frames = hparams.video_num_target_frames
except AttributeError:
num_target_frames = 1
features = {
"inputs": observations,
"input_action": tf.zeros(obs_shape[:2] + [1], dtype=tf.int32),
"input_reward": tf.zeros(obs_shape[:2] + [1], dtype=tf.int32),
"targets": tf.zeros(obs_shape[:1] + [num_target_frames] + obs_shape[2:]),
"target_action": tf.zeros(
obs_shape[:1] + [num_target_frames, 1], dtype=tf.int32),
"target_reward": tf.zeros(
obs_shape[:1] + [num_target_frames, 1], dtype=tf.int32),
"target_policy": tf.zeros(
obs_shape[:1] + [num_target_frames] + [action_space.n]),
"target_value": tf.zeros(
obs_shape[:1] + [num_target_frames])
}
with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):
t2t_model.create_dummy_vars()
(targets, _) = model(features)
return (targets["target_policy"][:, 0, :], targets["target_value"][:, 0]) | [
"Get a policy network.\n\n Args:\n observations: observations\n hparams: parameters\n action_space: action space\n\n Returns:\n Tuple (action logits, value).\n "
] |
Please provide a description of the function:def rlmf_tictactoe():
hparams = rlmf_original()
hparams.game = "tictactoe"
hparams.rl_env_name = "T2TEnv-TicTacToeEnv-v0"
# Since we don't have any no-op actions, otherwise we have to have an
# attribute called `get_action_meanings`.
hparams.eval_max_num_noops = 0
hparams.max_num_noops = 0
hparams.rl_should_derive_observation_space = False
hparams.policy_network = "feed_forward_categorical_policy"
hparams.base_algo_params = "ppo_ttt_params"
# Number of last observations to feed to the agent
hparams.frame_stack_size = 1
return hparams | [
"Base set of hparams for model-free PPO."
] |
Please provide a description of the function:def rlmf_tiny():
hparams = rlmf_original()
hparams = hparams.override_from_dict(rlmf_tiny_overrides())
hparams.batch_size = 2
hparams.base_algo_params = "ppo_original_tiny"
hparams.add_hparam("ppo_epochs_num", 3)
hparams.add_hparam("ppo_epoch_length", 2)
return hparams | [
"Tiny set of hparams for model-free PPO."
] |
Please provide a description of the function:def rlmf_dqn_tiny():
hparams = rlmf_original()
hparams = hparams.override_from_dict(rlmf_tiny_overrides())
hparams.batch_size = 1
hparams.base_algo = "dqn"
hparams.base_algo_params = "dqn_original_params"
hparams.add_hparam("dqn_num_frames", 128)
hparams.add_hparam("dqn_save_every_steps", 128)
hparams.add_hparam("dqn_replay_buffer_replay_capacity", 100)
hparams.add_hparam("dqn_agent_min_replay_history", 10)
return hparams | [
"Tiny DQN params."
] |
Please provide a description of the function:def rlmf_eval():
hparams = rlmf_original()
hparams.batch_size = 8
hparams.eval_sampling_temps = [0.0, 0.5, 1.0]
hparams.eval_rl_env_max_episode_steps = -1
hparams.add_hparam("ppo_epoch_length", 128)
hparams.add_hparam("ppo_optimization_batch_size", 32)
hparams.add_hparam("ppo_epochs_num", 10000)
hparams.add_hparam("ppo_eval_every_epochs", 500)
hparams.add_hparam("attempt", 0)
hparams.add_hparam("moe_loss_coef", 0)
return hparams | [
"Eval set of hparams for model-free PPO."
] |
Please provide a description of the function:def feed_forward_gaussian_fun(action_space, config, observations):
if not isinstance(action_space, gym.spaces.box.Box):
raise ValueError("Expecting continuous action space.")
mean_weights_initializer = tf.initializers.variance_scaling(
scale=config.init_mean_factor)
logstd_initializer = tf.random_normal_initializer(config.init_logstd, 1e-10)
flat_observations = tf.reshape(observations, [
tf.shape(observations)[0], tf.shape(observations)[1],
functools.reduce(operator.mul, observations.shape.as_list()[2:], 1)])
with tf.variable_scope("network_parameters"):
with tf.variable_scope("policy"):
x = flat_observations
for size in config.policy_layers:
x = tf.layers.dense(x, size, activation=tf.nn.relu)
mean = tf.layers.dense(
x, action_space.shape[0], activation=tf.tanh,
kernel_initializer=mean_weights_initializer)
logstd = tf.get_variable(
"logstd", mean.shape[2:], tf.float32, logstd_initializer)
logstd = tf.tile(
logstd[None, None],
[tf.shape(mean)[0], tf.shape(mean)[1]] + [1] * (mean.shape.ndims - 2))
with tf.variable_scope("value"):
x = flat_observations
for size in config.value_layers:
x = tf.layers.dense(x, size, activation=tf.nn.relu)
value = tf.layers.dense(x, 1)[..., 0]
mean = tf.check_numerics(mean, "mean")
logstd = tf.check_numerics(logstd, "logstd")
value = tf.check_numerics(value, "value")
policy = tfp.distributions.MultivariateNormalDiag(mean, tf.exp(logstd))
return NetworkOutput(policy, value, lambda a: tf.clip_by_value(a, -2., 2)) | [
"Feed-forward Gaussian."
] |
Please provide a description of the function:def _curvature_range(self):
self._curv_win = tf.get_variable("curv_win",
dtype=tf.float32,
trainable=False,
shape=[self.curvature_window_width,],
initializer=tf.zeros_initializer)
# We use log smoothing for curvature range
self._curv_win = tf.scatter_update(self._curv_win,
self._step % self.curvature_window_width,
tf.log(self._grad_norm_squared))
# Note here the iterations start from iteration 0
valid_window = tf.slice(self._curv_win,
tf.constant([0,]),
tf.expand_dims(
tf.minimum(
tf.constant(self.curvature_window_width),
self._step + 1), dim=0))
self._h_min_t = tf.reduce_min(valid_window)
self._h_max_t = tf.reduce_max(valid_window)
curv_range_ops = []
with tf.control_dependencies([self._h_min_t, self._h_max_t]):
avg_op = self._moving_averager.apply([self._h_min_t, self._h_max_t])
with tf.control_dependencies([avg_op]):
self._h_min = tf.exp(
tf.identity(self._moving_averager.average(self._h_min_t)))
self._h_max = tf.exp(
tf.identity(self._moving_averager.average(self._h_max_t)))
if self._sparsity_debias:
self._h_min *= self._sparsity_avg
self._h_max *= self._sparsity_avg
curv_range_ops.append(avg_op)
return curv_range_ops | [
"Curvature range.\n\n Returns:\n h_max_t, h_min_t ops\n "
] |
Please provide a description of the function:def _grad_variance(self):
grad_var_ops = []
tensor_to_avg = []
for t, g in zip(self._vars, self._grad):
if isinstance(g, tf.IndexedSlices):
tensor_to_avg.append(
tf.reshape(tf.unsorted_segment_sum(g.values,
g.indices,
g.dense_shape[0]),
shape=t.get_shape()))
else:
tensor_to_avg.append(g)
avg_op = self._moving_averager.apply(tensor_to_avg)
grad_var_ops.append(avg_op)
with tf.control_dependencies([avg_op]):
self._grad_avg = [self._moving_averager.average(val)
for val in tensor_to_avg]
self._grad_avg_squared = [tf.square(val) for val in self._grad_avg]
# Compute Variance
self._grad_var = tf.maximum(
tf.constant(1e-6, dtype=self._grad_norm_squared_avg.dtype),
self._grad_norm_squared_avg
- tf.add_n([tf.reduce_sum(val) for val in self._grad_avg_squared]))
if self._sparsity_debias:
self._grad_var *= self._sparsity_avg
return grad_var_ops | [
"Estimate of gradient Variance.\n\n Returns:\n C_t ops.\n "
] |
Please provide a description of the function:def _dist_to_opt(self):
dist_to_opt_ops = []
# Running average of the norm of gradient
self._grad_norm = tf.sqrt(self._grad_norm_squared)
avg_op = self._moving_averager.apply([self._grad_norm,])
dist_to_opt_ops.append(avg_op)
with tf.control_dependencies([avg_op]):
self._grad_norm_avg = self._moving_averager.average(self._grad_norm)
# Single iteration distance estimation, note here
# self._grad_norm_avg is per variable
self._d_t = self._grad_norm_avg / self._grad_norm_squared_avg
# Running average of distance
avg_op = self._moving_averager.apply([self._d_t])
dist_to_opt_ops.append(avg_op)
with tf.control_dependencies([avg_op]):
self._dist_to_opt_avg = tf.identity(
self._moving_averager.average(self._d_t))
if self._sparsity_debias:
self._dist_to_opt_avg /= tf.sqrt(self._sparsity_avg)
return dist_to_opt_ops | [
"Distance to optimum.\n\n Returns:\n D_t ops\n "
] |
Please provide a description of the function:def _grad_sparsity(self):
# If the sparse minibatch gradient has 10 percent of its entries
# non-zero, its sparsity is 0.1.
# The norm of dense gradient averaged from full dataset
# are roughly estimated norm of minibatch
# sparse gradient norm * sqrt(sparsity)
# An extension maybe only correct the sparse blob.
non_zero_cnt = tf.add_n([tf.count_nonzero(g) for g in self._grad])
all_entry_cnt = tf.add_n([tf.size(g) for g in self._grad])
self._sparsity = tf.cast(non_zero_cnt, self._grad[0].dtype)
self._sparsity /= tf.cast(all_entry_cnt, self._grad[0].dtype)
avg_op = self._moving_averager.apply([self._sparsity,])
with tf.control_dependencies([avg_op]):
self._sparsity_avg = self._moving_averager.average(self._sparsity)
return avg_op | [
"Gradient sparsity."
] |
Please provide a description of the function:def _prepare_variables(self):
self._moving_averager = tf.train.ExponentialMovingAverage(
decay=self._beta, zero_debias=self._zero_debias)
# assert self._grad is not None and len(self._grad) > 0
# List for the returned Operations
prepare_variables_op = []
# Get per var g**2 and norm**2
self._grad_squared = []
self._grad_norm_squared = []
# Gradient squared
for v, g in zip(self._vars, self._grad):
if g is None: continue
with tf.colocate_with(v):
self._grad_squared.append(tf.square(g))
# Norm squared.
self._grad_norm_squared = [tf.reduce_sum(g_sq)
for g_sq in self._grad_squared]
if self._sparsity_debias:
avg_op_sparsity = self._grad_sparsity()
prepare_variables_op.append(avg_op_sparsity)
# The following running average on squared norm of gradient
# is shared by grad_var and dist_to_opt
avg_op = self._moving_averager.apply(self._grad_norm_squared)
with tf.control_dependencies([avg_op]):
self._grad_norm_squared_avg = [self._moving_averager.average(val)
for val in self._grad_norm_squared]
self._grad_norm_squared = tf.add_n(self._grad_norm_squared)
self._grad_norm_squared_avg = tf.add_n(self._grad_norm_squared_avg)
prepare_variables_op.append(avg_op)
return tf.group(*prepare_variables_op) | [
"Prepare Variables for YellowFin.\n\n Returns:\n Grad**2, Norm, Norm**2, Mean(Norm**2) ops\n "
] |
Please provide a description of the function:def _get_cubic_root(self):
# We have the equation x^2 D^2 + (1-x)^4 * C / h_min^2
# where x = sqrt(mu).
# We substitute x, which is sqrt(mu), with x = y + 1.
# It gives y^3 + py = q
# where p = (D^2 h_min^2)/(2*C) and q = -p.
# We use the Vieta's substitution to compute the root.
# There is only one real solution y (which is in [0, 1] ).
# http://mathworld.wolfram.com/VietasSubstitution.html
assert_array = [
tf.Assert(
tf.logical_not(tf.is_nan(self._dist_to_opt_avg)),
[self._dist_to_opt_avg,]),
tf.Assert(
tf.logical_not(tf.is_nan(self._h_min)),
[self._h_min,]),
tf.Assert(
tf.logical_not(tf.is_nan(self._grad_var)),
[self._grad_var,]),
tf.Assert(
tf.logical_not(tf.is_inf(self._dist_to_opt_avg)),
[self._dist_to_opt_avg,]),
tf.Assert(
tf.logical_not(tf.is_inf(self._h_min)),
[self._h_min,]),
tf.Assert(
tf.logical_not(tf.is_inf(self._grad_var)),
[self._grad_var,])
]
with tf.control_dependencies(assert_array):
p = self._dist_to_opt_avg**2 * self._h_min**2 / 2 / self._grad_var
w3 = (-tf.sqrt(p**2 + 4.0 / 27.0 * p**3) - p) / 2.0
w = tf.sign(w3) * tf.pow(tf.abs(w3), 1.0/3.0)
y = w - p / 3.0 / w
x = y + 1
return x | [
"Get the cubic root."
] |
Please provide a description of the function:def _get_lr_tensor(self):
lr = tf.squared_difference(1.0, tf.sqrt(self._mu)) / self._h_min
return lr | [
"Get lr minimizing the surrogate.\n\n Returns:\n The lr_t.\n "
] |
Please provide a description of the function:def _get_mu_tensor(self):
root = self._get_cubic_root()
dr = self._h_max / self._h_min
mu = tf.maximum(
root**2, ((tf.sqrt(dr) - 1) / (tf.sqrt(dr) + 1))**2)
return mu | [
"Get the min mu which minimize the surrogate.\n\n Returns:\n The mu_t.\n "
] |
Please provide a description of the function:def _yellowfin(self):
# List for the returned Operations.
yellowfin_ops = []
# Curvature range ops.
curv_range_ops = self._curvature_range()
yellowfin_ops += curv_range_ops
# Estimate of gradient Variance ops.
grad_var_ops = self._grad_variance()
yellowfin_ops += grad_var_ops
# Distance to optimum ops.
dist_to_opt_ops = self._dist_to_opt()
yellowfin_ops += dist_to_opt_ops
# Single-Step: minimizes the surrogate for the expected
# squared distance from the optimum of a local quadratic
# approximation after a single step while keeping all directions in the
# robust region.
self._mu = tf.identity(tf.cond(self._do_tune,
self._get_mu_tensor,
lambda: self._mu_var))
with tf.control_dependencies([self._mu]):
self._lr = tf.identity(tf.cond(self._do_tune,
self._get_lr_tensor,
lambda: self._lr_var))
# Tune learning rate and momentum.
with tf.control_dependencies([self._mu, self._lr]):
self._mu = self._beta * self._mu_var + (1 - self._beta) * self._mu
self._lr = self._beta * self._lr_var + (1 - self._beta) * self._lr
yellowfin_ops.append(tf.assign(self._mu_var, self._mu))
yellowfin_ops.append(tf.assign(self._lr_var, self._lr))
yellowfin_ops = tf.group(*yellowfin_ops)
return yellowfin_ops | [
"YellowFin auto-tuning optimizer based on momentum SGD.\n\n Returns:\n YF ops\n (Curvature range,\n Grad_variance,\n Dist_to_opt,\n Single-Step,\n Auto-Tuning)\n "
] |
Please provide a description of the function:def apply_gradients(self, grads_and_vars, global_step=None, name=None):
self._grad, self._vars = zip(*[(g, t)
for g, t in grads_and_vars if g is not None])
# Var update with Momentum.
with tf.variable_scope("apply_updates"):
# Gradient Clipping?
if self._clip_thresh_var is not None:
self._grad, _ = tf.clip_by_global_norm(
self._grad, self._clip_thresh_var)
apply_grad_op = self._momentum_optimizer.apply_gradients(
zip(self._grad, self._vars),
global_step=global_step,
name=name)
else:
apply_grad_op = self._momentum_optimizer.apply_gradients(
zip(self._grad, self._vars),
global_step=global_step,
name=name)
# Begin lr and mu tuning.
with tf.variable_scope("prepare_yellowFin_variables"):
# the dependencies ideally only need to be after clip is done,
# i.e. depends on self._grads. However, the control_dependencies
# does not support indexed slice for sparse gradients.
# The alternative dependencies here might be slightly slower due
# to less parallelization.
with tf.control_dependencies([apply_grad_op,]):
prepare_variables_op = self._prepare_variables()
with tf.variable_scope("yellowfin"):
with tf.control_dependencies([prepare_variables_op]):
yellowfin_op = self._yellowfin()
# Update YellowFin step variable.
with tf.control_dependencies([yellowfin_op]):
self._increment_step_op = tf.assign_add(self._step, 1).op
return tf.group(apply_grad_op,
prepare_variables_op,
yellowfin_op,
self._increment_step_op) | [
"Applying gradients and tune hyperparams with YellowFin.\n\n Args:\n grads_and_vars: List of (gradient, variable) pairs as returned by\n compute_gradients().\n global_step: Optional Variable to increment by one after the\n variables have been updated.\n name: Optional name for the returned operation. Default to the\n name passed to the Optimizer constructor.\n\n Returns:\n (A group of operations)\n Variable Update with Momentum ops,\n YellowFin ops(Curvature, Variance, Distance) ops,\n SingleStep and lr_mu tuning ops,\n Step increment ops.\n "
] |
Please provide a description of the function:def compute_gradients(self,
loss,
var_list,
global_step=None,
gate_gradients=GATE_OP,
aggregation_method=None,
colocate_gradients_with_ops=False,
name=None,
grad_loss=None):
del global_step, name # Unused for now.
return self._momentum_optimizer.compute_gradients(
loss,
var_list=var_list,
gate_gradients=gate_gradients,
aggregation_method=aggregation_method,
colocate_gradients_with_ops=colocate_gradients_with_ops,
grad_loss=grad_loss) | [
"Compute gradients through momentum optimizer.\n\n Args:\n loss: A Tensor containing the value to minimize.\n var_list: Optional list or tuple of tf.Variable to update\n to minimize loss. Defaults to the list of variables collected\n in the graph under the key GraphKey.TRAINABLE_VARIABLES.\n global_step: Optional Variable to increment by one after the\n variables have been updated.\n gate_gradients: How to gate the computation of gradients.\n Can be GATE_NONE, GATE_OP, or GATE_GRAPH.\n aggregation_method: Specifies the method used to combine\n gradient terms. Valid values are defined in the class AggregationMethod.\n colocate_gradients_with_ops: If True, try collocating gradients with\n the corresponding op.\n name: Optional name for the returned operation. Default to the name\n passed to the Optimizer constructor.\n grad_loss: Optional. A Tensor holding the gradient computed for loss.\n\n Returns:\n A list of (gradient, variable) pairs. Variable is always present,\n but gradient can be None.\n "
] |
Please provide a description of the function:def minimize(self,
loss,
global_step=None,
var_list=None,
gate_gradients=GATE_OP,
aggregation_method=None,
colocate_gradients_with_ops=False,
name=None,
grad_loss=None):
grads_and_vars = self._momentum_optimizer.compute_gradients(
loss,
var_list=var_list,
gate_gradients=gate_gradients,
aggregation_method=aggregation_method,
colocate_gradients_with_ops=colocate_gradients_with_ops,
grad_loss=grad_loss)
vars_with_grad = [v for g, v in grads_and_vars if g is not None]
if not vars_with_grad:
raise ValueError(
"No gradients provided for any variable, check your graph for ops"
" that do not support gradients, between variables %s and loss %s." %
([str(v) for _, v in grads_and_vars], loss))
for g, v in grads_and_vars:
print("g ", g)
print("v ", v)
return self.apply_gradients(grads_and_vars,
global_step=global_step,
name=name) | [
"Adapted from TensorFlow Optimizer base class member function.\n\n Add operations to minimize `loss` by updating `var_list`.\n This method simply combines calls `compute_gradients()` and\n `apply_gradients()`. If you want to process the gradient before applying\n them call `tf.gradients()` and `self.apply_gradients()` explicitly instead\n of using this function.\n\n Args:\n loss: A Tensor containing the value to minimize.\n global_step: Optional Variable to increment by one after the variables\n have been updated.\n var_list: Optional list or tuple of Variable objects to update to\n minimize loss. Defaults to the list of variables collected in\n the graph under the key GraphKeys.TRAINABLE_VARIABLES.\n gate_gradients: How to gate the computation of gradients.\n Can be GATE_NONE, GATE_OP, or GATE_GRAPH.\n aggregation_method: Specifies the method used to combine gradient terms.\n Valid values are defined in the class AggregationMethod.\n colocate_gradients_with_ops: If True, try collocating gradients with\n the corresponding op.\n name: Optional name for the returned operation.\n grad_loss: Optional. A Tensor holding the gradient computed for loss.\n\n Returns:\n An Operation that updates the variables in var_list.\n If global_step was not None, that operation also increments global_step.\n\n Raises:\n ValueError: if no gradients are provided for any variable.\n "
] |
Please provide a description of the function:def residual_dilated_conv(x, repeat, padding, name, hparams):
with tf.variable_scope(name):
k = (hparams.kernel_height, hparams.kernel_width)
dilations_and_kernels = [((2**i, 1), k)
for i in range(hparams.num_hidden_layers)]
for i in range(repeat):
with tf.variable_scope("repeat_%d" % i):
y = common_layers.conv_block(
common_layers.layer_norm(x, hparams.hidden_size, name="lnorm"),
hparams.hidden_size,
dilations_and_kernels,
padding=padding,
name="residual_conv")
y = tf.nn.dropout(y, 1.0 - hparams.dropout)
x += y
return x | [
"A stack of convolution blocks with residual connections."
] |
Please provide a description of the function:def bytenet_internal(inputs, targets, hparams):
with tf.variable_scope("bytenet"):
# Flatten inputs and extend length by 50%.
inputs = tf.expand_dims(common_layers.flatten4d3d(inputs), axis=2)
extend_length = tf.to_int32(0.5 * tf.to_float(tf.shape(inputs)[1]))
inputs_shape = inputs.shape.as_list()
inputs = tf.pad(inputs, [[0, 0], [0, extend_length], [0, 0], [0, 0]])
inputs_shape[1] = None
inputs.set_shape(inputs_shape) # Don't lose the other shapes when padding.
# Pad inputs and targets to be the same length, divisible by 50.
inputs, targets = common_layers.pad_to_same_length(
inputs, targets, final_length_divisible_by=50)
final_encoder = residual_dilated_conv(inputs, hparams.num_block_repeat,
"SAME", "encoder", hparams)
shifted_targets = common_layers.shift_right(targets)
kernel = (hparams.kernel_height, hparams.kernel_width)
decoder_start = common_layers.conv_block(
tf.concat([final_encoder, shifted_targets], axis=3),
hparams.hidden_size, [((1, 1), kernel)],
padding="LEFT")
return residual_dilated_conv(decoder_start, hparams.num_block_repeat,
"LEFT", "decoder", hparams) | [
"ByteNet, main step used for training."
] |
Please provide a description of the function:def bytenet_base():
hparams = common_hparams.basic_params1()
hparams.batch_size = 2048
hparams.hidden_size = 768
hparams.dropout = 0.2
hparams.symbol_dropout = 0.2
hparams.label_smoothing = 0.1
hparams.clip_grad_norm = 2.0
hparams.num_hidden_layers = 4
hparams.kernel_height = 3
hparams.kernel_width = 1
hparams.learning_rate_decay_scheme = "exp"
hparams.learning_rate = 0.05
hparams.learning_rate_warmup_steps = 3000
hparams.initializer_gain = 1.0
hparams.weight_decay = 3.0
hparams.num_sampled_classes = 0
hparams.sampling_method = "argmax"
hparams.optimizer_adam_epsilon = 1e-6
hparams.optimizer_adam_beta1 = 0.85
hparams.optimizer_adam_beta2 = 0.997
hparams.add_hparam("num_block_repeat", 4)
return hparams | [
"Set of hyperparameters."
] |
Please provide a description of the function:def _download_and_parse_dataset(tmp_dir, train):
file_path = generator_utils.maybe_download(tmp_dir, _SNLI_ZIP, _SNLI_URL)
zip_ref = zipfile.ZipFile(file_path, 'r')
zip_ref.extractall(tmp_dir)
zip_ref.close()
file_name = 'train' if train else 'dev'
dataset_file_path = os.path.join(tmp_dir, _SNLI_DATA_PATH % file_name)
_parse_dataset(dataset_file_path, tmp_dir, train) | [
"Downloads and prepairs the dataset to be parsed by the data_generator."
] |
Please provide a description of the function:def _get_tokens_and_tags(parse_str):
tokens = []
parse_split = parse_str.split(' ')
for p in parse_split:
assert p.startswith('(') or p.endswith(')')
if p.endswith(')'):
token = p.replace(')', '')
tokens.append(token)
return tokens | [
"Parse str to tokens and pos tags."
] |
Please provide a description of the function:def _parse_dataset(file_path, tmp_dir, train):
input_path = file_path
file_name = 'train' if train else 'dev'
gen_output_path = os.path.join(tmp_dir, file_name + '.txt')
example_output_path = os.path.join(tmp_dir, _EXAMPLES_FILE)
print('input path: ' + input_path)
print('gen_output_path: ' + gen_output_path)
print('example_output_path: ' + example_output_path)
input_file = tf.gfile.Open(input_path, mode='r')
examples = []
for counter, line in enumerate(input_file):
if counter == 0: # Ignore first line since its a header.
continue
# Get the token and embedding vector.
line_split = line.split('\t')
parse1 = line_split[_PARSE1_INDEX]
parse2 = line_split[_PARSE2_INDEX]
consensus_label = line_split[_LABEL_INDEX]
tokens1 = _get_tokens_and_tags(parse1)
tokens2 = _get_tokens_and_tags(parse2)
tokens1_str = ' '.join(tokens1)
tokens2_str = ' '.join(tokens2)
if consensus_label != '-':
examples.append([tokens1_str, tokens2_str, consensus_label])
input_file.close()
# Output tab delimited file of lines of examples (sentence1, sentence2, label)
with tf.gfile.GFile(gen_output_path, 'w') as f:
for tokens1_str, tokens2_str, consensus_label in examples:
f.write('%s\t%s\t%s\n' % (tokens1_str, tokens2_str, consensus_label))
if train:
# Output file containing all the sentences for generating the vocab from.
with tf.gfile.GFile(example_output_path, 'w') as f:
for tokens1_str, tokens2_str, consensus_label in examples:
f.write('%s %s\n' % (tokens1_str, tokens2_str)) | [
"Convert the dataset in to a simpler format.\n\n This function creates two files. One for being processed to produce a vocab\n and another to generate the data.\n\n Args:\n file_path: string, path to the file to parse.\n tmp_dir: string, path to the directory to output the files.\n train: bool, indicating if we are parsing the training set.\n "
] |
Please provide a description of the function:def _get_or_generate_vocab(tmp_dir, vocab_filename, vocab_size):
vocab_filepath = os.path.join(tmp_dir, vocab_filename)
print('Vocab file written to: ' + vocab_filepath)
if tf.gfile.Exists(vocab_filepath):
gs = text_encoder.SubwordTextEncoder(vocab_filepath)
return gs
example_file = os.path.join(tmp_dir, _EXAMPLES_FILE)
gs = text_encoder.SubwordTextEncoder()
token_counts = tokenizer.corpus_token_counts(
example_file, corpus_max_lines=1000000)
gs = gs.build_to_target_size(
vocab_size, token_counts, min_val=1, max_val=1e3)
gs.store_to_file(vocab_filepath)
return gs | [
"Read or create vocabulary."
] |
Please provide a description of the function:def snli_token_generator(tmp_dir, train, vocab_size):
_download_and_parse_dataset(tmp_dir, train)
symbolizer_vocab = _get_or_generate_vocab(
tmp_dir, 'vocab.subword_text_encoder', vocab_size)
file_name = 'train' if train else 'dev'
data_file = os.path.join(tmp_dir, file_name + '.txt')
with tf.gfile.GFile(data_file, mode='r') as f:
for line in f:
sent1, sent2, label = line.strip().split('\t')
sent1_enc = symbolizer_vocab.encode(sent1)
sent2_enc = symbolizer_vocab.encode(sent2)
inputs = sent1_enc + [_SEP] + sent2_enc + [_EOS]
yield {
'inputs': inputs,
'targets': [_LABEL_TO_ID[label]],
} | [
"Generate example dicts."
] |
Please provide a description of the function:def shard(items, num_shards):
sharded = []
num_per_shard = len(items) // num_shards
start = 0
for _ in range(num_shards):
sharded.append(items[start:start + num_per_shard])
start += num_per_shard
remainder = len(items) % num_shards
start = len(items) - remainder
for i in range(remainder):
sharded[i].append(items[start + i])
assert sum([len(fs) for fs in sharded]) == len(items)
return sharded | [
"Split items into num_shards groups."
] |
Please provide a description of the function:def RandomNormalInitializer(stddev=1e-2):
def init(shape, rng):
return (stddev * backend.random.normal(rng, shape)).astype('float32')
return init | [
"An initializer function for random normal coefficients."
] |
Please provide a description of the function:def GlorotNormalInitializer(out_dim=0, in_dim=1, scale=onp.sqrt(2)):
def init(shape, rng):
fan_in, fan_out = shape[in_dim], shape[out_dim]
size = onp.prod(onp.delete(shape, [in_dim, out_dim]))
std = scale / np.sqrt((fan_in + fan_out) / 2. * size)
return (std * backend.random.normal(rng, shape)).astype('float32')
return init | [
"An initializer function for random Glorot-scaled coefficients."
] |
Please provide a description of the function:def GlorotUniformInitializer(out_dim=0, in_dim=1):
def init(shape, rng):
fan_in, fan_out = shape[in_dim], shape[out_dim]
std = np.sqrt(2.0 / (fan_in + fan_out))
a = np.sqrt(3.0) * std
return backend.random.uniform(rng, shape, minval=-a, maxval=a)
return init | [
"An initializer function for random uniform Glorot-scaled coefficients."
] |
Please provide a description of the function:def one_hot(x, size, dtype=np.float32):
return np.array(x[..., np.newaxis] == np.arange(size), dtype) | [
"Make a n+1 dim one-hot array from n dim int-categorical array."
] |
Please provide a description of the function:def LogSoftmax(x, params, axis=-1, **kwargs):
del params, kwargs
return x - backend.logsumexp(x, axis, keepdims=True) | [
"Apply log softmax to x: log-normalize along the given axis."
] |
Please provide a description of the function:def Softmax(x, params, axis=-1, **kwargs):
del params, kwargs
return np.exp(x - backend.logsumexp(x, axis, keepdims=True)) | [
"Apply softmax to x: exponentiate and normalize along the given axis."
] |
Please provide a description of the function:def padtype_to_pads(in_shape, window_shape, window_strides, padding):
padding = padding.upper()
if padding == 'SAME':
out_shape = onp.ceil(
onp.true_divide(in_shape, window_strides)).astype(int)
pad_sizes = [max((out_size - 1) * stride + window_shape - in_size, 0)
for out_size, stride, window_shape, in_size
in zip(out_shape, window_strides, window_shape, in_shape)]
return [(pad_size // 2, pad_size - pad_size // 2)
for pad_size in pad_sizes]
elif padding == 'VALID':
return [(0, 0)] * len(in_shape)
else:
msg = 'Unknown padding type: {}.'
raise TypeError(msg.format(padding)) | [
"Convert padding string to list of pairs of pad values."
] |
Please provide a description of the function:def _flatten_output_shape(input_shape, num_axis_to_keep=1):
if num_axis_to_keep >= len(input_shape):
raise ValueError(
"num_axis_to_keep[%d] should be less than input's rank[%d]" %
(num_axis_to_keep, len(input_shape)))
return tuple(input_shape[:num_axis_to_keep]) + (
reduce(op.mul, input_shape[num_axis_to_keep:], 1),) | [
"Output shape of a flatten layer."
] |
Please provide a description of the function:def _batch_norm_new_params(input_shape, rng, axis=(0, 1, 2),
center=True, scale=True, **kwargs):
del rng, kwargs
axis = (axis,) if np.isscalar(axis) else axis
shape = tuple(d for i, d in enumerate(input_shape) if i not in axis)
beta = np.zeros(shape, dtype='float32') if center else ()
gamma = np.ones(shape, dtype='float32') if scale else ()
return (beta, gamma) | [
"Helper to initialize batch norm params."
] |
Please provide a description of the function:def BatchNorm(x, params, axis=(0, 1, 2), epsilon=1e-5,
center=True, scale=True, **unused_kwargs):
mean = np.mean(x, axis, keepdims=True)
# Fast but less numerically-stable variance calculation than np.var.
m1 = np.mean(x**2, axis, keepdims=True)
var = m1 - mean**2
z = (x - mean) / np.sqrt(var + epsilon)
# Expand the parameters to have the right axes.
beta, gamma = params
# TODO(phawkins): np.expand_dims should accept an axis tuple.
# (https://github.com/numpy/numpy/issues/12290)
ed = tuple(None if i in axis else slice(None) for i in range(np.ndim(x)))
beta = beta[ed]
gamma = gamma[ed]
# Return the z rescaled by the parameters if requested.
if center and scale:
return gamma * z + beta
if center:
return z + beta
if scale:
return gamma * z
return z | [
"Layer construction function for a batch normalization layer."
] |
Please provide a description of the function:def _pooling_output_shape(input_shape, pool_size=(2, 2),
strides=None, padding='VALID'):
dims = (1,) + pool_size + (1,) # NHWC
spatial_strides = strides or (1,) * len(pool_size)
strides = (1,) + spatial_strides + (1,)
pads = padtype_to_pads(input_shape, dims, strides, padding)
operand_padded = onp.add(input_shape, onp.add(*zip(*pads)))
t = onp.floor_divide(onp.subtract(operand_padded, dims), strides) + 1
return tuple(t) | [
"Helper: compute the output shape for the pooling layer."
] |
Please provide a description of the function:def _pooling_general(inputs, reducer, init_val, rescaler=None,
pool_size=(2, 2), strides=None, padding='VALID'):
spatial_strides = strides or (1,) * len(pool_size)
rescale = rescaler(pool_size, spatial_strides, padding) if rescaler else None
dims = (1,) + pool_size + (1,) # NHWC
strides = (1,) + spatial_strides + (1,)
out = lax.reduce_window(inputs, init_val, reducer, dims, strides, padding)
return rescale(out, inputs) if rescale else out | [
"Helper: general pooling computation used in pooling layers later."
] |
Please provide a description of the function:def Dropout(x, params, rate=0.0, mode='train', rng=None, **kwargs):
del params, kwargs
if rng is None:
msg = ('Dropout layer requires apply_fun to be called with a rng keyword '
'argument. That is, instead of `Dropout(params, inputs)`, call '
'it like `Dropout(params, inputs, rng=key)`.')
raise ValueError(msg)
if rate >= 1.0:
raise ValueError('Dropout rate (%f) must be lower than 1.' % rate)
if mode == 'train' and rate > 0.0:
keep = backend.random.bernoulli(rng, 1.0 - rate, x.shape)
return np.where(keep, x / (1.0 - rate), 0)
else:
return x | [
"Layer construction function for a dropout layer with given rate."
] |
Please provide a description of the function:def _kernel_shape(self, input_shape):
kernel_size_iter = iter(self._kernel_size)
return [self._filters if c == 'O' else
input_shape[self._lhs_spec.index('C')] if c == 'I' else
next(kernel_size_iter) for c in self._rhs_spec] | [
"Helper to calculate the kernel shape."
] |
Please provide a description of the function:def _conv_shape_tuple(self, lhs_shape, rhs_shape, strides, pads):
if isinstance(pads, str):
pads = padtype_to_pads(lhs_shape[2:], rhs_shape[2:], strides, pads)
if len(pads) != len(lhs_shape) - 2:
msg = 'Wrong number of explicit pads for conv: expected {}, got {}.'
raise TypeError(msg.format(len(lhs_shape) - 2, len(pads)))
lhs_padded = onp.add(lhs_shape[2:], onp.add(*zip(*pads)))
out_space = onp.floor_divide(
onp.subtract(lhs_padded, rhs_shape[2:]), strides) + 1
out_space = onp.maximum(0, out_space)
out_shape = (lhs_shape[0], rhs_shape[0]) + tuple(out_space)
return tuple(out_shape) | [
"Compute the shape of a conv given input shapes in canonical order."
] |
Please provide a description of the function:def _conv_general_permutations(self, dimension_numbers):
lhs_spec, rhs_spec, out_spec = dimension_numbers
lhs_char, rhs_char, out_char = ('N', 'C'), ('O', 'I'), ('N', 'C')
charpairs = (lhs_char, rhs_char, out_char)
for i, (a, b) in enumerate(charpairs):
if not (dimension_numbers[i].count(a) == 1 and
dimension_numbers[i].count(b) == 1):
msg = ('convolution dimension_numbers[{}] must contain the characters '
'"{}" and "{}" exatly once, got {}.')
raise TypeError(msg.format(i, a, b, dimension_numbers[i]))
if len(dimension_numbers[i]) != len(set(dimension_numbers[i])):
msg = ('convolution dimension_numbers[{}] cannot have duplicate '
'characters, got {}.')
raise TypeError(msg.format(i, dimension_numbers[i]))
if not (set(lhs_spec) - set(lhs_char) == set(rhs_spec) - set(rhs_char) ==
set(out_spec) - set(out_char)):
msg = ('convolution dimension_numbers elements must each have the same '
'set of spatial characters, got {}.')
raise TypeError(msg.format(dimension_numbers))
def getperm(spec, charpair):
spatial = (i for i, c in enumerate(spec) if c not in charpair)
if spec is not rhs_spec:
spatial = sorted(spatial, key=lambda i: rhs_spec.index(spec[i]))
return (spec.index(charpair[0]), spec.index(charpair[1])) + tuple(spatial)
lhs_perm, rhs_perm, out_perm = map(getperm, dimension_numbers, charpairs)
return lhs_perm, rhs_perm, out_perm | [
"Utility for convolution dimension permutations relative to Conv HLO."
] |
Please provide a description of the function:def _conv_general_shape_tuple(self, lhs_shape, rhs_shape, window_strides,
padding, dimension_numbers):
lhs_perm, rhs_perm, out_perm = self._conv_general_permutations(
dimension_numbers)
lhs_trans = onp.take(lhs_shape, lhs_perm)
rhs_trans = onp.take(rhs_shape, rhs_perm)
out_trans = self._conv_shape_tuple(
lhs_trans, rhs_trans, window_strides, padding)
return tuple(onp.take(out_trans, onp.argsort(out_perm))) | [
"Generalized computation of conv shape."
] |
Please provide a description of the function:def get_create_agent(agent_kwargs):
def create_agent(sess, environment, summary_writer=None):
return BatchDQNAgent(
env_batch_size=environment.batch_size,
sess=sess,
num_actions=environment.action_space.n,
summary_writer=summary_writer,
tf_device="/gpu:*",
**agent_kwargs)
return create_agent | [
"Factory for dopamine agent initialization.\n\n Args:\n agent_kwargs: dict of BatchDQNAgent parameters\n\n Returns:\n Function(sess, environment, summary_writer) -> BatchDQNAgent instance.\n ",
"Creates a DQN agent.\n\n Simplified version of `dopamine.discrete_domains.train.create_agent`\n\n Args:\n sess: a session\n environment: an environment\n summary_writer: a summary writer.\n\n Returns:\n a DQN agent.\n "
] |
Please provide a description of the function:def get_create_batch_env_fun(batch_env_fn, time_limit):
def create_env_fun(game_name=None, sticky_actions=None):
del game_name, sticky_actions
batch_env = batch_env_fn(in_graph=False)
batch_env = ResizeBatchObservation(batch_env) # pylint: disable=redefined-variable-type
batch_env = DopamineBatchEnv(batch_env, max_episode_steps=time_limit)
return batch_env
return create_env_fun | [
"Factory for dopamine environment initialization function.\n\n Args:\n batch_env_fn: function(in_graph: bool) -> batch environment.\n time_limit: time steps limit for environment.\n\n Returns:\n function (with optional, unused parameters) initializing environment.\n "
] |
Please provide a description of the function:def _parse_hparams(hparams):
prefixes = ["agent_", "optimizer_", "runner_", "replay_buffer_"]
ret = []
for prefix in prefixes:
ret_dict = {}
for key in hparams.values():
if prefix in key:
par_name = key[len(prefix):]
ret_dict[par_name] = hparams.get(key)
ret.append(ret_dict)
return ret | [
"Split hparams, based on key prefixes.\n\n Args:\n hparams: hyperparameters\n\n Returns:\n Tuple of hparams for respectably: agent, optimizer, runner, replay_buffer.\n "
] |
Please provide a description of the function:def _build_replay_buffer(self, use_staging):
replay_buffer_kwargs = dict(
observation_shape=dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,
stack_size=dqn_agent.NATURE_DQN_STACK_SIZE,
replay_capacity=self._replay_capacity,
batch_size=self._buffer_batch_size,
update_horizon=self.update_horizon,
gamma=self.gamma,
extra_storage_types=None,
observation_dtype=np.uint8,
)
replay_memory = _OutOfGraphReplayBuffer(
artificial_done=not self._generates_trainable_dones,
**replay_buffer_kwargs)
return circular_replay_buffer.WrappedReplayBuffer(
wrapped_memory=replay_memory,
use_staging=use_staging,
**replay_buffer_kwargs) | [
"Build WrappedReplayBuffer with custom OutOfGraphReplayBuffer."
] |
Please provide a description of the function:def add(self, observation, action, reward, terminal, *args):
# If this will be a problem for maintenance, we could probably override
# DQNAgent.add() method instead.
artificial_done = self._artificial_done and terminal
args = list(args)
args.append(artificial_done)
return super(_OutOfGraphReplayBuffer, self).add(observation, action, reward,
terminal, *args) | [
"Append artificial_done to *args and run parent method."
] |
Please provide a description of the function:def step(self, actions):
self._elapsed_steps += 1
obs, rewards, dones = \
[np.array(r) for r in self.batch_env.step(actions)]
if self._elapsed_steps > self._max_episode_steps:
done = True
if self._elapsed_steps > self._max_episode_steps + 1:
rewards.fill(0)
else:
done = dones[0]
assert np.all(done == dones), ("Current modifications of Dopamine "
"require same number of steps for each "
"environment in batch")
del dones
self.game_over = done
return obs, rewards, done, {} | [
"Step."
] |
Please provide a description of the function:def text_cnn_base():
hparams = common_hparams.basic_params1()
hparams.batch_size = 4096
hparams.max_length = 256
hparams.clip_grad_norm = 0. # i.e. no gradient clipping
hparams.optimizer_adam_epsilon = 1e-9
hparams.learning_rate_schedule = "legacy"
hparams.learning_rate_decay_scheme = "noam"
hparams.learning_rate = 0.1
hparams.learning_rate_warmup_steps = 4000
hparams.initializer_gain = 1.0
hparams.num_hidden_layers = 6
hparams.initializer = "uniform_unit_scaling"
hparams.weight_decay = 0.0
hparams.optimizer_adam_beta1 = 0.9
hparams.optimizer_adam_beta2 = 0.98
hparams.num_sampled_classes = 0
hparams.label_smoothing = 0.1
hparams.shared_embedding_and_softmax_weights = True
hparams.symbol_modality_num_shards = 16
# Add new ones like this.
hparams.add_hparam("filter_sizes", [2, 3, 4, 5])
hparams.add_hparam("num_filters", 128)
hparams.add_hparam("output_dropout", 0.4)
return hparams | [
"Set of hyperparameters."
] |
Please provide a description of the function:def next_frame_glow_hparams():
hparams = glow.glow_hparams()
# Possible modes are conditional and unconditional
hparams.add_hparam("gen_mode", "conditional")
hparams.add_hparam("learn_top_scale", False)
hparams.add_hparam("condition_all_levels", True)
# For each video, substitutes "num_input_frames + num_output_frames" with a
# randomly sampled patch of length "num_train_frames" during training.
# -1 indicates that the entire video is used for training.
hparams.add_hparam("num_train_frames", -1)
# The following are hparams that model the latent transitions.
# Encoder that maps the latents to a Gaussian distribution.
# This function is used to model the prior over z_{t}. Can be,
# Pointwise -> point-wise multiplication of z_{t-1}.
# conv_net -> one-layer convolution over z_{t-1} .. z_{t - num_cond_latents}
# conv3d_net or conv_lstm
hparams.add_hparam("latent_dist_encoder", "conv_net")
# Number of latents used in the encoder above.
hparams.add_hparam("num_cond_latents", 1)
hparams.add_hparam("latent_architecture", "glow_resnet")
hparams.add_hparam("latent_apply_dilations", False)
hparams.add_hparam("latent_dilation_rates", [1, 3])
# Use latent skip connections
hparams.add_hparam("model_input", False)
hparams.add_hparam("cond_first_frame", False)
hparams.add_hparam("latent_skip", True)
hparams.add_hparam("latent_encoder_depth", 2)
hparams.add_hparam("latent_encoder_width", 512)
hparams.add_hparam("latent_dropout", 0.0)
hparams.add_hparam("latent_pre_output_channels", 512)
hparams.add_hparam("latent_activation", "relu")
hparams.add_hparam("latent_noise", 0.0)
# Pretrains the glow encoder for "pretrain_steps" number of steps.
# By default, don't pretrain and learn end-to-end
hparams.add_hparam("pretrain_steps", -1)
hparams.bottom = {
"inputs": modalities.video_raw_bottom,
"targets": modalities.video_raw_targets_bottom,
}
hparams.loss = {
"targets": modalities.video_l1_raw_loss,
}
hparams.top = {
"targets": modalities.video_raw_top,
}
hparams.init_batch_size = 256
hparams.batch_size = 32
# Possible options: are prev_frame, single_conv and normal
hparams.top_prior = "single_conv"
return hparams | [
"Hparams for next_frame_glow."
] |
Please provide a description of the function:def next_frame_glow_bair_quant():
hparams = next_frame_glow_hparams()
hparams.video_num_input_frames = 3
hparams.video_num_target_frames = 10
hparams.num_train_frames = 4
hparams.num_cond_latents = 3
hparams.depth = 24
hparams.latent_dist_encoder = "conv3d_net"
hparams.latent_encoder_width = 256
hparams.latent_architecture = "glow_resnet"
hparams.latent_encoder_depth = 5
hparams.latent_apply_dilations = True
hparams.latent_activation = "gatu"
hparams.activation = "gatu"
hparams.learning_rate_constant = 3e-4
hparams.learning_rate_schedule = "constant*linear_warmup"
hparams.learning_rate_warmup_steps = 10000
hparams.init_batch_size = 128
hparams.batch_size = 5
return hparams | [
"Hparams to reproduce bits-per-pixel results on BAIR action-free dataset."
] |
Please provide a description of the function:def next_frame_glow_bair_qual():
hparams = next_frame_glow_bair_quant()
hparams.coupling = "additive"
hparams.temperature = 0.5
hparams.coupling_width = 392
return hparams | [
"Hparams for qualitative video generation results."
] |
Please provide a description of the function:def next_frame_glow_shapes():
hparams = next_frame_glow_bair_quant()
hparams.video_num_input_frames = 1
hparams.video_num_target_frames = 2
hparams.num_train_frames = 2
hparams.num_cond_latents = 1
hparams.coupling = "additive"
hparams.coupling_width = 512
hparams.latent_encoder_depth = 10
hparams.latent_skip = False
hparams.learning_rate_constant = 1e-4
hparams.batch_size = 10
return hparams | [
"Hparams for qualitative and quantitative results on shapes dataset."
] |
Please provide a description of the function:def get_cond_latents(all_latents=None, hparams=None):
cond_latents = None
if hparams.gen_mode == "conditional":
if hparams.latent_dist_encoder in ["conv_net", "conv3d_net"]:
num_cond_latents = (hparams.num_cond_latents +
int(hparams.cond_first_frame))
if len(all_latents) >= num_cond_latents:
cond_latents = all_latents[-hparams.num_cond_latents:]
if hparams.cond_first_frame:
cond_latents = [all_latents[0]] + cond_latents
elif hparams.latent_dist_encoder in ["pointwise", "conv_lstm"]:
if all_latents:
cond_latents = all_latents[-1]
if hparams.gen_mode == "conditional":
global_step = tf.train.get_or_create_global_step()
condition = tf.greater(global_step, hparams.pretrain_steps)
else:
condition = tf.constant(False, dtype=tf.bool)
return condition, cond_latents | [
"Get z^{cond}_{t} given z^{1..t-1}.\n\n Args:\n all_latents: list of list of tensors,\n outer-size equals no.of time_steps-1\n inner-size equals hparams.n_levels.\n hparams: See next_frame_glow_hparams.\n Returns:\n cond_latents: conditional latents at time-step t.\n "
] |
Please provide a description of the function:def basic_fc_small():
hparams = common_hparams.basic_params1()
hparams.learning_rate = 0.1
hparams.batch_size = 128
hparams.hidden_size = 256
hparams.num_hidden_layers = 2
hparams.initializer = "uniform_unit_scaling"
hparams.initializer_gain = 1.0
hparams.weight_decay = 0.0
hparams.dropout = 0.0
return hparams | [
"Small fully connected model."
] |
Please provide a description of the function:def _layer_stack(mp,
inputs,
self_attention_bias,
layers,
hparams,
encoder_output=None,
encoder_decoder_attention_bias=None):
layers = layers.strip(",").split(",")
# scaled_dot_product_attention_with_projections uses a 3d attention bias
# (no heads), where multihead_attention uses 4d attention bias.
self_attention_bias_3d = mp(tf.squeeze, self_attention_bias, 1)
if encoder_decoder_attention_bias is not None:
encoder_decoder_attention_bias_3d = mp(
tf.squeeze, encoder_decoder_attention_bias, 1)
relu_dropout_broadcast_dims = (
common_layers.comma_separated_string_to_integer_list(
getattr(hparams, "relu_dropout_broadcast_dims", "")))
mix_size = int(hparams.mix_fraction * hparams.hidden_size)
accumulator = inputs
x = inputs
for layer_num, layer_type in enumerate(layers):
with tf.variable_scope("%s_%d" % (layer_type, layer_num)):
tf.logging.info("%s_%d" % (layer_type, layer_num))
if layer_type == "a":
# accumulate
accumulator = mp(tf.add, x, accumulator)
x = accumulator
elif layer_type == "n":
# normalize
x = mp(common_layers.apply_norm,
x, hparams.norm_type, hparams.hidden_size, hparams.norm_epsilon)
elif layer_type == "d":
# dropout
x = mp(tf.nn.dropout, x, 1.0 - hparams.layer_prepostprocess_dropout)
elif layer_type == "m":
if mix_size > 0:
# mix across shards
def _split(t):
return tuple(tf.split(
t, [mix_size, hparams.hidden_size - mix_size], 2))
to_mix, to_keep = mp(_split, x)
mixed = expert_utils.all_reduce_ring(to_mix, mp)
mixed = mp(tf.multiply, mixed, mp.n ** -0.5)
x = mp(lambda a, b: tf.concat([a, b], 2), mixed, to_keep)
elif layer_type == "att":
# single-head attention
q = mp(tf.layers.dense, x, hparams.hidden_size, use_bias=False,
name="q_transform")
x = mp(
common_attention.scaled_dot_product_attention_simple,
q, x, x, self_attention_bias_3d)
x = mp(tf.layers.dense, x, hparams.hidden_size, use_bias=False,
name="o_transform")
elif layer_type == "enc-att":
# single-head attention over encoder
q = mp(tf.layers.dense, x, hparams.hidden_size, use_bias=False,
name="q_transform")
assert encoder_output is not None
x = mp(
common_attention.scaled_dot_product_attention_simple,
q, encoder_output, encoder_output,
encoder_decoder_attention_bias_3d)
x = mp(tf.layers.dense, x, hparams.hidden_size, use_bias=False,
name="o_transform")
elif layer_type == "multihead-att":
# multi-head attention
x = mp(
common_attention.multihead_attention,
x,
None,
self_attention_bias, # bias
hparams.multihead_attention_key_channels or hparams.hidden_size,
hparams.multihead_attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.multihead_attention_num_heads,
hparams.attention_dropout)
elif layer_type == "enc-multihead-att":
# multi-head attention
x = mp(
common_attention.multihead_attention,
x,
encoder_output,
encoder_decoder_attention_bias, # bias
hparams.multihead_attention_key_channels or hparams.hidden_size,
hparams.multihead_attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.multihead_attention_num_heads,
hparams.attention_dropout)
elif layer_type == "ffn":
x = mp(
common_layers.dense_relu_dense, x,
hparams.filter_size, hparams.hidden_size,
dropout=hparams.relu_dropout,
dropout_broadcast_dims=[relu_dropout_broadcast_dims] * mp.n)
else:
assert False, "unknown sublayer %s" % layer_type
return x | [
"A stack of layers.\n\n Args:\n mp: a Parallelism object\n inputs: a list of Tensors\n self_attention_bias: list of bias Tensor for self-attention\n (see common_attention.attention_bias())\n layers: a string\n hparams: hyperparameters for model\n encoder_output: optional list of tensors\n encoder_decoder_attention_bias: optional list of tensors\n\n Returns:\n y: a list of Tensors\n "
] |
Please provide a description of the function:def transformer_symshard_base():
hparams = common_hparams.basic_params1()
hparams.hidden_size = 256
hparams.batch_size = 2048
hparams.max_length = 0
# All hyperparameters ending in "dropout" are automatically set to 0.0
# when not in training mode.
hparams.layer_prepostprocess_dropout = 0.2
hparams.add_hparam("attention_dropout", 0.1)
hparams.add_hparam("relu_dropout", 0.0)
hparams.add_hparam("relu_dropout_broadcast_dims", "1")
hparams.layer_prepostprocess_dropout = 0.1
hparams.layer_prepostprocess_dropout_broadcast_dims = "1" # length
hparams.label_smoothing = 0.1
hparams.clip_grad_norm = 0. # i.e. no gradient clipping
hparams.optimizer = "Adafactor"
hparams.learning_rate_schedule = "rsqrt_decay"
hparams.learning_rate_warmup_steps = 10000
hparams.initializer_gain = 1.0
hparams.initializer = "uniform_unit_scaling"
hparams.weight_decay = 0.0
# TODO(noam): use this to control sharing. We now share always
hparams.shared_embedding_and_softmax_weights = True
# we only want one data shard.
hparams.no_data_parallelism = True
# bypass the symbol modality so that we can use model parallelism.
hparams.bottom = {
"inputs": modalities.identity_bottom,
"targets": modalities.identity_bottom,
}
hparams.top = {
"targets": modalities.identity_top,
}
hparams.add_hparam("filter_size", 1280)
hparams.add_hparam("mix_fraction", 0.5)
# attention-related flags
hparams.add_hparam("multihead_attention_num_heads", 4)
hparams.add_hparam("multihead_attention_key_channels", 0)
hparams.add_hparam("multihead_attention_value_channels", 0)
hparams.add_hparam("pos", "timing") # timing, none
hparams.add_hparam(
"encoder_layers", ("n,att,m,d,a," "n,ffn,m,d,a,") * 6 + "n,d")
hparams.add_hparam(
"decoder_layers",
("n,att,m,d,a," "n,enc-att,m,d,a," "n,ffn,m,d,a,") * 6 + "n,d")
# Number of model shards - each one has separate parameters.
# Changing this number invalidates checkpoints.
hparams.add_hparam("num_model_shards", 8)
return hparams | [
"Set of hyperparameters."
] |
Please provide a description of the function:def imagenet_pixelrnn_generator(tmp_dir,
training,
size=_IMAGENET_SMALL_IMAGE_SIZE):
if size == _IMAGENET_SMALL_IMAGE_SIZE:
train_prefix = _IMAGENET_SMALL_TRAIN_PREFIX
eval_prefix = _IMAGENET_SMALL_EVAL_PREFIX
else:
train_prefix = _IMAGENET_MEDIUM_TRAIN_PREFIX
eval_prefix = _IMAGENET_MEDIUM_EVAL_PREFIX
prefix = train_prefix if training else eval_prefix
images_filepath = os.path.join(tmp_dir, prefix)
image_files = tf.gfile.Glob(images_filepath + "/*")
height = size
width = size
const_label = 0
for filename in image_files:
with tf.gfile.Open(filename, "r") as f:
encoded_image = f.read()
yield {
"image/encoded": [encoded_image],
"image/format": ["png"],
"image/class/label": [const_label],
"image/height": [height],
"image/width": [width]
} | [
"Image generator for Imagenet 64x64 downsampled images.\n\n It assumes that the data has been downloaded from\n http://image-net.org/small/*_32x32.tar or\n http://image-net.org/small/*_64x64.tar into tmp_dir.\n Args:\n tmp_dir: path to temporary storage directory.\n training: a Boolean; if true, we use the train set, otherwise the test set.\n size: image size (assumes height and width are same)\n\n Yields:\n A dictionary representing the images with the following fields:\n * image/encoded: the string encoding the image as JPEG,\n * image/format: the string \"jpeg\" representing image format,\n * image/height: an integer representing the height,\n * image/width: an integer representing the width.\n Every field is actually a list of the corresponding type.\n "
] |
Please provide a description of the function:def imagenet_preprocess_example(example, mode, resize_size=None,
normalize=True):
resize_size = resize_size or [299, 299]
assert resize_size[0] == resize_size[1]
image = example["inputs"]
if mode == tf.estimator.ModeKeys.TRAIN:
image = preprocess_for_train(image, image_size=resize_size[0],
normalize=normalize)
else:
image = preprocess_for_eval(image, image_size=resize_size[0],
normalize=normalize)
example["inputs"] = image
return example | [
"Preprocessing used for Imagenet and similar problems."
] |
Please provide a description of the function:def _crop(image, offset_height, offset_width, crop_height, crop_width):
original_shape = tf.shape(image)
rank_assertion = tf.Assert(
tf.equal(tf.rank(image), 3), ["Rank of image must be equal to 3."])
with tf.control_dependencies([rank_assertion]):
cropped_shape = tf.stack([crop_height, crop_width, original_shape[2]])
size_assertion = tf.Assert(
tf.logical_and(
tf.greater_equal(original_shape[0], crop_height),
tf.greater_equal(original_shape[1], crop_width)),
["Crop size greater than the image size."])
offsets = tf.to_int32(tf.stack([offset_height, offset_width, 0]))
# Use tf.slice instead of crop_to_bounding box as it accepts tensors to
# define the crop size.
with tf.control_dependencies([size_assertion]):
image = tf.slice(image, offsets, cropped_shape)
return tf.reshape(image, cropped_shape) | [
"Crops the given image using the provided offsets and sizes.\n\n Note that the method doesn't assume we know the input image size but it does\n assume we know the input image rank.\n\n Args:\n image: `Tensor` image of shape [height, width, channels].\n offset_height: `Tensor` indicating the height offset.\n offset_width: `Tensor` indicating the width offset.\n crop_height: the height of the cropped image.\n crop_width: the width of the cropped image.\n\n Returns:\n the cropped (and resized) image.\n\n Raises:\n InvalidArgumentError: if the rank is not 3 or if the image dimensions are\n less than the crop size.\n "
] |
Please provide a description of the function:def distorted_bounding_box_crop(image,
bbox,
min_object_covered=0.1,
aspect_ratio_range=(0.75, 1.33),
area_range=(0.05, 1.0),
max_attempts=100,
scope=None):
with tf.name_scope(scope, default_name="distorted_bounding_box_crop",
values=[image, bbox]):
# Each bounding box has shape [1, num_boxes, box coords] and
# the coordinates are ordered [ymin, xmin, ymax, xmax].
# A large fraction of image datasets contain a human-annotated bounding
# box delineating the region of the image containing the object of interest.
# We choose to create a new bounding box for the object which is a randomly
# distorted version of the human-annotated bounding box that obeys an
# allowed range of aspect ratios, sizes and overlap with the human-annotated
# bounding box. If no box is supplied, then we assume the bounding box is
# the entire image.
sample_distorted_bounding_box = tf.image.sample_distorted_bounding_box(
tf.shape(image),
bounding_boxes=bbox,
min_object_covered=min_object_covered,
aspect_ratio_range=aspect_ratio_range,
area_range=area_range,
max_attempts=max_attempts,
use_image_if_no_bounding_boxes=True)
bbox_begin, bbox_size, distort_bbox = sample_distorted_bounding_box
# Crop the image to the specified bounding box.
cropped_image = tf.slice(image, bbox_begin, bbox_size)
return cropped_image, distort_bbox | [
"Generates cropped_image using a one of the bboxes randomly distorted.\n\n See `tf.image.sample_distorted_bounding_box` for more documentation.\n\n Args:\n image: `Tensor` of image (it will be converted to floats in [0, 1]).\n bbox: `Tensor` of bounding boxes arranged `[1, num_boxes, coords]`\n where each coordinate is [0, 1) and the coordinates are arranged\n as `[ymin, xmin, ymax, xmax]`. If num_boxes is 0 then use the whole\n image.\n min_object_covered: An optional `float`. Defaults to `0.1`. The cropped\n area of the image must contain at least this fraction of any bounding\n box supplied.\n aspect_ratio_range: An optional list of `float`s. The cropped area of the\n image must have an aspect ratio = width / height within this range.\n area_range: An optional list of `float`s. The cropped area of the image\n must contain a fraction of the supplied image within in this range.\n max_attempts: An optional `int`. Number of attempts at generating a cropped\n region of the image of the specified constraints. After `max_attempts`\n failures, return the entire image.\n scope: Optional `str` for name scope.\n Returns:\n (cropped image `Tensor`, distorted bbox `Tensor`).\n "
] |
Please provide a description of the function:def _random_crop(image, size):
bbox = tf.constant([0.0, 0.0, 1.0, 1.0], dtype=tf.float32, shape=[1, 1, 4])
random_image, bbox = distorted_bounding_box_crop(
image,
bbox,
min_object_covered=0.1,
aspect_ratio_range=(3. / 4, 4. / 3.),
area_range=(0.08, 1.0),
max_attempts=1,
scope=None)
bad = _at_least_x_are_true(tf.shape(image), tf.shape(random_image), 3)
image = tf.cond(
bad, lambda: _center_crop(_do_scale(image, size), size),
lambda: tf.image.resize_bicubic([random_image], [size, size])[0])
return image | [
"Make a random crop of (`size` x `size`)."
] |
Please provide a description of the function:def _at_least_x_are_true(a, b, x):
match = tf.equal(a, b)
match = tf.cast(match, tf.int32)
return tf.greater_equal(tf.reduce_sum(match), x) | [
"At least `x` of `a` and `b` `Tensors` are true."
] |
Please provide a description of the function:def _do_scale(image, size):
shape = tf.cast(tf.shape(image), tf.float32)
w_greater = tf.greater(shape[0], shape[1])
shape = tf.cond(w_greater,
lambda: tf.cast([shape[0] / shape[1] * size, size], tf.int32),
lambda: tf.cast([size, shape[1] / shape[0] * size], tf.int32))
return tf.image.resize_bicubic([image], shape)[0] | [
"Rescale the image by scaling the smaller spatial dimension to `size`."
] |
Please provide a description of the function:def _center_crop(image, size):
image_height = tf.shape(image)[0]
image_width = tf.shape(image)[1]
offset_height = ((image_height - size) + 1) / 2
offset_width = ((image_width - size) + 1) / 2
image = _crop(image, offset_height, offset_width, size, size)
return image | [
"Crops to center of image with specified `size`."
] |
Please provide a description of the function:def _normalize(image):
offset = tf.constant(MEAN_RGB, shape=[1, 1, 3])
image -= offset
scale = tf.constant(STDDEV_RGB, shape=[1, 1, 3])
image /= scale
return image | [
"Normalize the image to zero mean and unit variance."
] |
Please provide a description of the function:def preprocess_for_train(image, image_size=224, normalize=True):
if normalize: image = tf.to_float(image) / 255.0
image = _random_crop(image, image_size)
if normalize: image = _normalize(image)
image = _flip(image)
image = tf.reshape(image, [image_size, image_size, 3])
return image | [
"Preprocesses the given image for evaluation.\n\n Args:\n image: `Tensor` representing an image of arbitrary size.\n image_size: int, how large the output image should be.\n normalize: bool, if True the image is normalized.\n\n Returns:\n A preprocessed image `Tensor`.\n "
] |
Please provide a description of the function:def preprocess_for_eval(image, image_size=224, normalize=True):
if normalize: image = tf.to_float(image) / 255.0
image = _do_scale(image, image_size + 32)
if normalize: image = _normalize(image)
image = _center_crop(image, image_size)
image = tf.reshape(image, [image_size, image_size, 3])
return image | [
"Preprocesses the given image for evaluation.\n\n Args:\n image: `Tensor` representing an image of arbitrary size.\n image_size: int, how large the output image should be.\n normalize: bool, if True the image is normalized.\n\n Returns:\n A preprocessed image `Tensor`.\n "
] |
Please provide a description of the function:def MultifactorSchedule(history=None,
factors="constant * linear_warmup * rsqrt_decay",
constant=0.1,
warmup_steps=100,
decay_factor=0.5,
steps_per_decay=20000):
del history
cache_args = (factors, constant, warmup_steps)
if cache_args in _memoized_multifactor_schedules:
return _memoized_multifactor_schedules[cache_args]
factors = [n.strip() for n in factors.split("*")]
def learning_rate(step): # pylint: disable=invalid-name
ret = 1.0
for name in factors:
if name == "constant":
ret *= constant
elif name == "linear_warmup":
ret *= np.minimum(1.0, step / warmup_steps)
elif name == "rsqrt_decay":
ret /= np.sqrt(np.maximum(step, warmup_steps))
elif name == "decay_every":
ret *= (decay_factor ** (step//steps_per_decay))
else:
raise ValueError("Unknown factor %s." % name)
return ret
_memoized_multifactor_schedules[cache_args] = learning_rate
return learning_rate | [
"Factor-based learning rate schedule.\n\n Interprets factors in the factors string which can consist of:\n * constant: interpreted as the constant value,\n * linear_warmup: interpreted as linear warmup until warmup_steps,\n * rsqrt_decay: divide by square root of max(step, warmup_steps)\n * decay_every: Every k steps decay the learning rate by decay_factor.\n\n Args:\n history: the history of training and evaluation (History object).\n factors: a string with factors separated by \"*\" that defines the schedule.\n constant: float, the starting constant for the learning rate schedule.\n warmup_steps: how many steps to warm up for in the warmup schedule.\n decay_factor: The amount to decay the learning rate by.\n steps_per_decay: How often to decay the learning rate.\n\n Returns:\n a function learning_rate(step): float -> float, the step-dependent lr.\n ",
"Step to learning rate function."
] |
Please provide a description of the function:def EvalAdjustingSchedule(history,
constant=0.1,
steps_to_decrease=20,
improvement_margin=0.001,
decrease_rate=1.5,
history_mode="eval",
metric="metrics/accuracy"):
metrics = history.get(history_mode, metric)
adjusted = constant
if len(metrics) < 2:
return MultifactorSchedule(history, constant=adjusted)
steps_without_improvement = 0
cur = metrics.pop()[1] # The most-recent value of the metric.
while len(metrics) > 1:
# The one-before value of metrics as .pop() removes one element each time.
prev = metrics.pop()[1]
if cur < prev * (1 + improvement_margin):
steps_without_improvement += 1
else:
cur = prev
steps_without_improvement = 0
if steps_without_improvement >= steps_to_decrease:
adjusted /= decrease_rate
cur = prev
steps_without_improvement = 0
return MultifactorSchedule(history, constant=adjusted) | [
"Learning rate that decreases when eval metric stalls.\n\n If the chosen metric does not improve by improvement_margin for as many as\n steps_to_decrease steps, then the constant gets decreased by decrease rate.\n Finally, the MultifactorSchedule gets called with the adjusted constant.\n\n Args:\n history: trax.history.History, the history of training and evaluation.\n constant: float, the starting constant for the learning rate schedule.\n steps_to_decrease: int, after how many steps without improvement\n should we decrease the constant.\n improvement_margin: how much we need to improve to consider the metric\n improved.\n decrease_rate: by what fraction to decrease (i.e. lr /= decrease_rate).\n history_mode: str, which mode of the history to use.\n metric: which evaluation metric to use for adjustments.\n\n Returns:\n a function learning_rate(step): float -> float, the step-dependent lr.\n "
] |
Please provide a description of the function:def project_hidden(x, projection_tensors, hidden_size, num_blocks):
batch_size, latent_dim, _ = common_layers.shape_list(x)
x = tf.reshape(x, shape=[1, -1, hidden_size])
x_tiled = tf.reshape(
tf.tile(x, multiples=[num_blocks, 1, 1]),
shape=[num_blocks, -1, hidden_size])
x_projected = tf.matmul(x_tiled, projection_tensors)
x_projected = tf.transpose(x_projected, perm=[1, 0, 2])
x_4d = tf.reshape(x_projected, [batch_size, latent_dim, num_blocks, -1])
return x_4d | [
"Project encoder hidden state under num_blocks using projection tensors.\n\n Args:\n x: Encoder hidden state of shape [batch_size, latent_dim, hidden_size].\n projection_tensors: Projection tensors used to project the hidden state.\n hidden_size: Dimension of the latent space.\n num_blocks: Number of blocks in DVQ.\n\n Returns:\n x_projected: Projected states of shape [batch_size, latent_dim, num_blocks,\n hidden_size / num_blocks].\n "
] |
Please provide a description of the function:def slice_hidden(x, hidden_size, num_blocks):
batch_size, latent_dim, _ = common_layers.shape_list(x)
block_dim = hidden_size // num_blocks
x_sliced = tf.reshape(x,
shape=[batch_size, latent_dim, num_blocks, block_dim])
return x_sliced | [
"Slice encoder hidden state under num_blocks.\n\n Args:\n x: Encoder hidden state of shape [batch_size, latent_dim, hidden_size].\n hidden_size: Dimension of the latent space.\n num_blocks: Number of blocks in DVQ.\n\n Returns:\n Sliced states of shape [batch_size, latent_dim, num_blocks, block_dim].\n "
] |
Please provide a description of the function:def nearest_neighbor(x,
means,
block_v_size,
random_top_k=1,
soft_em=False,
num_samples=1,
sum_over_latents=False,
summary=True):
batch_size, latent_dim, num_blocks, block_dim = common_layers.shape_list(x)
x = tf.reshape(x, [batch_size * latent_dim, num_blocks, block_dim])
x_norm_sq = tf.reduce_sum(tf.square(x), axis=-1, keep_dims=True)
means_norm_sq = tf.reduce_sum(tf.square(means), axis=-1, keep_dims=True)
scalar_prod = tf.matmul(
tf.transpose(x, perm=[1, 0, 2]), tf.transpose(means, perm=[0, 2, 1]))
scalar_prod = tf.transpose(scalar_prod, perm=[1, 0, 2])
dist = x_norm_sq + tf.transpose(
means_norm_sq, perm=[2, 0, 1]) - 2 * scalar_prod
# computing cluster probabilities
if soft_em:
num_blocks = common_layers.shape_list(dist)[1]
nearest_idx = tf.stack(
[
tf.multinomial(-dist[:, i, :], num_samples=num_samples)
for i in range(num_blocks)
],
axis=1)
nearest_hot = tf.one_hot(nearest_idx, depth=block_v_size)
neg_q_entropy = tf.reduce_sum(
nearest_hot * tf.expand_dims(tf.nn.log_softmax(-dist), 2), axis=2)
if sum_over_latents:
neg_q_entropy = tf.reduce_sum(neg_q_entropy, [1, 2])
neg_q_entropy = tf.reduce_mean(neg_q_entropy, axis=0)
nearest_hot = tf.reduce_mean(nearest_hot, axis=-2)
if summary:
tf.summary.histogram("neg_q_entropy", tf.reshape(neg_q_entropy, [-1]))
else:
neg_q_entropy = 0.
if random_top_k > 1:
_, top_k_idx = tf.nn.top_k(-dist, k=random_top_k)
nearest_idx = tf.gather(
top_k_idx,
tf.random_uniform(
[1], minval=0, maxval=random_top_k - 1, dtype=tf.int32),
axis=-1)
else:
nearest_idx = tf.argmax(-dist, axis=-1)
nearest_hot = tf.one_hot(nearest_idx, block_v_size)
return nearest_hot, neg_q_entropy | [
"Find the nearest element in means to elements in x.\n\n Args:\n x: Continuous encodings of shape [batch_size, latent_dim, num_blocks,\n block_dim].\n means: Embedding table of shape [num_blocks, block_v_size, block_dim].\n block_v_size: Number of table entries per block.\n random_top_k: Noisy top-k if this is bigger than 1.\n soft_em: If True then use soft EM rather than hard EM.\n num_samples: Number of samples to take in soft EM.\n sum_over_latents: Whether to sum over non-batch dimensions when calculating\n negative entropy loss. Used only when doing soft EM.\n summary: If True then record summary histogram of entropies.\n\n Returns:\n Tensor with nearest element in mean encoded in one-hot notation\n and distances.\n "
] |
Please provide a description of the function:def embedding_lookup(x,
means,
num_blocks,
block_v_size,
bottleneck_kind="dvq",
random_top_k=1,
soft_em=False,
num_samples=1,
do_hard_gumbel_softmax=False,
temperature_warmup_steps=150000,
num_flows=0,
approximate_gs_entropy=False,
sum_over_latents=False):
if bottleneck_kind == "gumbel-softmax-dvq":
x_means_hot, neg_q_entropy = gumbel_softmax_nearest_neighbor_dvq(
x,
means,
block_v_size,
hard=do_hard_gumbel_softmax,
num_samples=num_samples,
temperature_warmup_steps=temperature_warmup_steps,
num_flows=num_flows,
approximate_gs_entropy=approximate_gs_entropy,
sum_over_latents=sum_over_latents)
else:
x_means_hot, neg_q_entropy = nearest_neighbor(
x,
means,
block_v_size,
random_top_k,
soft_em=soft_em,
num_samples=num_samples,
sum_over_latents=sum_over_latents)
x_means_hot_flat = tf.reshape(x_means_hot, [-1, num_blocks, block_v_size])
x_means = tf.matmul(tf.transpose(x_means_hot_flat, perm=[1, 0, 2]), means)
x_means = tf.transpose(x_means, [1, 0, 2])
batch_size, latent_dim, num_blocks, block_dim = common_layers.shape_list(x)
x = tf.reshape(x, [batch_size * latent_dim, num_blocks, block_dim])
# Currently, we use the mean scaling for the commitment loss, as opposed to
# summing across all non-batch dimensions.
q_loss = tf.reduce_mean(tf.squared_difference(tf.stop_gradient(x), x_means))
e_loss = tf.reduce_mean(tf.squared_difference(x, tf.stop_gradient(x_means)))
return x_means_hot, x_means, q_loss, e_loss, neg_q_entropy | [
"Compute nearest neighbors and loss for training the embeddings via DVQ.\n\n Args:\n x: Continuous encodings of shape [batch_size, latent_dim, num_blocks,\n block_dim].\n means: Embedding table of shape [num_blocks, block_v_size, block_dim].\n num_blocks: Number of blocks in DVQ.\n block_v_size: Number of table entries per block.\n bottleneck_kind: Discrete bottleneck type.\n random_top_k: Noisy top-k if this is bigger than 1.\n soft_em: If True then use soft EM rather than hard EM.\n num_samples: Number of samples to use for soft EM.\n do_hard_gumbel_softmax: Whether to use hard or soft Gumbel-Softmax samples\n for gumbel-softmax-dvq bottleneck.\n temperature_warmup_steps: Number of steps it takes to decay temperature to\n 0. Used only if bottleneck_kind is gumbel-softmax-dvq.\n num_flows: Number of inverse autoregressive flows for gumbel-softmax-dvq\n bottleneck.\n approximate_gs_entropy: Whether to approximate the Gumbel-Softmax density\n as a categorical distribution when calculating the sample entropy. Used\n only if bottleneck_kind is gumbel-softmax-dvq.\n sum_over_latents: Whether to sum over non-batch dimensions when calculating\n negative entropy loss. Used only if soft EM or when bottleneck_kind is\n gumbel-softmax-dvq.\n\n Returns:\n x_means_hot: The nearest neighbor in one hot form, with shape\n [batch_size * latent_dim, num_blocks, block_v_size].\n x_means: The nearest neighbor itself, with shape [batch_size * latent_dim,\n num_blocks, block_dim].\n q_loss: Scalar Tensor representing codebook loss.\n e_loss: Scalar Tensor representing commitment loss.\n neg_q_entropy: Scalar Tensor representing negative entropy of variational\n approximation (0 if it is deterministic).\n "
] |
Please provide a description of the function:def bit_to_int(x_bit, num_bits, base=2):
x_l = tf.stop_gradient(tf.to_int32(tf.reshape(x_bit, [-1, num_bits])))
x_labels = [
x_l[:, i] * tf.to_int32(base)**tf.to_int32(i) for i in range(num_bits)]
res = sum(x_labels)
return tf.to_int32(tf.reshape(res, common_layers.shape_list(x_bit)[:-1])) | [
"Turn x_bit representing numbers bitwise (lower-endian) to int tensor.\n\n Args:\n x_bit: Tensor containing numbers in a particular base to be converted to\n int.\n num_bits: Number of bits in the representation.\n base: Base of the representation.\n\n Returns:\n Integer representation of this number.\n "
] |
Please provide a description of the function:def int_to_bit_embed(x_int, num_bits, embedding_size, base=2):
shape = common_layers.shape_list(x_int)
inputs = int_to_bit(x_int, num_bits, base=base)
inputs = tf.reshape(inputs, shape[:-1] + [shape[-1] * 8])
inputs = 2.0 * tf.to_float(inputs) - 1.0 # Move from 0/1 to -1/1.
return tf.layers.dense(inputs, embedding_size, name="int_to_bit_embed") | [
"Turn x_int into a bitwise (lower-endian) tensor and embed densly."
] |
Please provide a description of the function:def embed(x,
hidden_size,
z_size,
filter_size,
bottleneck_kind="dvq",
soft_em=False,
num_blocks=2,
num_residuals=1,
block_v_size=None,
means=None,
name=None):
with tf.variable_scope(name, default_name="embed", reuse=tf.AUTO_REUSE):
if bottleneck_kind == "semhash":
c = int_to_bit(x, z_size)
h1a = tf.layers.dense(c, filter_size, name="vch1a")
h1b = tf.layers.dense(1.0 - c, filter_size, name="vch1b")
h1 = h1a + h1b
elif bottleneck_kind == "gumbel-softmax":
hot = tf.one_hot(x, 2**z_size)
h1 = tf.layers.dense(hot, hidden_size, name="dae_dense")
elif bottleneck_kind in ["dvq", "gumbel-softmax-dvq"]:
if block_v_size is None:
raise ValueError("Bottleneck kind is dvq but block_v_size is None.")
if soft_em:
assert num_residuals == 1
x_hot_flat = tf.reshape(x, shape=[-1, num_blocks, block_v_size])
h1 = tf.matmul(tf.transpose(x_hot_flat, perm=[1, 0, 2]), means[0])
h1 = tf.transpose(h1, perm=[1, 0, 2])
new_shape = common_layers.shape_list(x)
new_shape[-1] = hidden_size
h1 = tf.reshape(h1, shape=new_shape)
else:
shape_x = common_layers.shape_list(x)
x_flat = tf.reshape(x, [-1, 1])
c = int_to_bit(x_flat, num_bits=z_size, base=2)
shape = common_layers.shape_list(c)
new_shape = shape
new_shape[-1] = num_residuals
new_shape.append(num_blocks)
new_shape.append(int(z_size / (num_residuals * num_blocks)))
c = tf.to_int32(tf.reshape(c, shape=new_shape))
h1_shape = shape_x
h1_shape.append(hidden_size)
h1 = tf.zeros(dtype=tf.float32, shape=h1_shape)
for i in range(num_residuals):
c_residual = bit_to_int(
c[:, :, i, :, :],
num_bits=int(z_size / (num_residuals * num_blocks)),
base=2)
c_hot = tf.one_hot(c_residual, depth=block_v_size, axis=-1)
c_hot_flat = tf.reshape(c_hot, shape=[-1, num_blocks, block_v_size])
h1_residual = tf.matmul(
tf.transpose(c_hot_flat, perm=[1, 0, 2]), means[i])
h1_residual = tf.transpose(h1_residual, perm=[1, 0, 2])
h1_residual = tf.reshape(h1_residual, shape=h1_shape)
h1 += h1_residual
elif bottleneck_kind == "rounding":
h1 = x
else:
raise ValueError("Unknown bottleneck kind.")
return h1 | [
"Embedding function that takes discrete latent and returns embedding.\n\n Args:\n x: Input to the discretization bottleneck.\n hidden_size: Dimension of the latent state.\n z_size: Number of bits, where discrete codes range from 1 to 2**z_size.\n filter_size: Dimension to project embedding by. Used only if bottleneck_kind\n is semhash.\n bottleneck_kind: Kind of discretization bottleneck to use; one of dvq,\n semhash, gumbel-softmax (Default: dvq).\n soft_em: If True then it uses a multi-sample version of EM (Default: False).\n num_blocks: Number of blocks in DVQ (Default: 2).\n num_residuals: Number of residuals (Default: 1).\n block_v_size: Number of embedding entries per block (Default: None).\n means: The embedding table for dvq (Default: None).\n name: Name for the bottleneck scope.\n\n Returns:\n Continuous embedding to be passed on to the decoder.\n\n Raises:\n ValueError: For unknown or missing arguments.\n "
] |
Please provide a description of the function:def vae(x, z_size, name=None):
with tf.variable_scope(name, default_name="vae"):
mu = tf.layers.dense(x, z_size, name="mu")
log_sigma = tf.layers.dense(x, z_size, name="log_sigma")
shape = common_layers.shape_list(x)
epsilon = tf.random_normal([shape[0], shape[1], 1, z_size])
z = mu + tf.exp(log_sigma / 2) * epsilon
kl = 0.5 * tf.reduce_mean(
tf.expm1(log_sigma) + tf.square(mu) - log_sigma, axis=-1)
free_bits = z_size // 4
kl_loss = tf.reduce_mean(tf.maximum(kl - free_bits, 0.0))
return z, kl_loss, mu, log_sigma | [
"Simple variational autoencoder without discretization.\n\n Args:\n x: Input to the discretization bottleneck.\n z_size: Number of bits, where discrete codes range from 1 to 2**z_size.\n name: Name for the bottleneck scope.\n\n Returns:\n Embedding function, latent, loss, mu and log_simga.\n "
] |
Please provide a description of the function:def gumbel_sample(shape):
uniform_samples = tf.random_uniform(shape, minval=0.00001, maxval=0.99998)
return -tf.log(-tf.log(uniform_samples)) | [
"Sample from the Gumbel distribution, protect from overflows.\n\n Args:\n shape: Shape of Gumbel samples.\n\n Returns:\n Noise drawn from Gumbel distribution.\n "
] |
Please provide a description of the function:def gumbel_softmax(x,
z_size,
mode,
softmax_k=0,
temperature_warmup_steps=150000,
summary=True,
name=None):
with tf.variable_scope(name, default_name="gumbel_softmax"):
m = tf.layers.dense(x, 2**z_size, name="mask")
if softmax_k > 0:
m, kl = top_k_softmax(m, softmax_k)
return m, m, 1.0 - tf.reduce_mean(kl)
logsm = tf.nn.log_softmax(m)
# Gumbel-softmax sample.
gumbel_samples = gumbel_sample(common_layers.shape_list(m))
steps = temperature_warmup_steps
gumbel_samples *= common_layers.inverse_exp_decay(steps // 5) * 0.5
temperature = 1.2 - common_layers.inverse_lin_decay(steps)
# 10% of the time keep reasonably high temperature to keep learning.
temperature = tf.cond(
tf.less(tf.random_uniform([]), 0.9), lambda: temperature,
lambda: tf.random_uniform([], minval=0.5, maxval=1.0))
s = tf.nn.softmax((logsm + gumbel_samples) / temperature)
m = tf.nn.softmax(m)
kl = -tf.reduce_max(logsm, axis=-1)
if summary:
tf.summary.histogram("max-log", tf.reshape(kl, [-1]))
# Calculate the argmax and construct hot vectors.
maxvec = tf.reshape(tf.argmax(m, axis=-1), [-1])
maxvhot = tf.stop_gradient(tf.one_hot(maxvec, 2**z_size))
# Add losses that prevent too few being used.
distrib = tf.reshape(logsm, [-1, 2**z_size]) * maxvhot
d_mean = tf.reduce_mean(distrib, axis=[0], keep_dims=True)
d_variance = tf.reduce_mean(
tf.squared_difference(distrib, d_mean), axis=[0])
d_dev = -tf.reduce_mean(d_variance)
ret = s
if mode != tf.estimator.ModeKeys.TRAIN:
ret = tf.reshape(maxvhot, common_layers.shape_list(s)) # Just hot @eval.
return m, ret, d_dev * 5.0 + tf.reduce_mean(kl) * 0.002 | [
"Gumbel softmax discretization bottleneck.\n\n Args:\n x: Input to the discretization bottleneck.\n z_size: Number of bits, where discrete codes range from 1 to 2**z_size.\n mode: tf.estimator.ModeKeys.\n softmax_k: If > 0 then do top-k softmax.\n temperature_warmup_steps: Number of steps it takes to decay temperature to\n 0.\n summary: Whether to write summaries.\n name: Name for the bottleneck scope.\n\n Returns:\n Embedding function, discrete code, and loss.\n "
] |
Please provide a description of the function:def discrete_bottleneck(inputs,
hidden_size,
z_size,
filter_size,
mode=None,
bottleneck_kind="dvq",
num_blocks=2,
num_residuals=1,
reshape_method="slice",
projection_tensors=None,
beta=0.25,
ema=True,
means=None,
ema_count=None,
ema_means=None,
epsilon=1e-5,
decay=0.999,
random_top_k=1,
soft_em=False,
num_samples=1,
softmax_k=0,
temperature_warmup_steps=150000,
do_hard_gumbel_softmax=False,
num_flows=0,
approximate_gs_entropy=False,
sum_over_latents=False,
discrete_mix=0.5,
noise_dev=1.,
startup_steps=50000,
summary=True,
name=None,
cond=True):
if bottleneck_kind in ["dvq", "gumbel-softmax-dvq"]:
assert means is not None
if hidden_size % num_blocks != 0:
raise ValueError("num_blocks does not divide hidden size")
if z_size % num_residuals != 0:
raise ValueError("num_residuals does not divide embedding table size")
z_size_per_residual = int(z_size / num_residuals)
if z_size_per_residual % num_blocks != 0:
raise ValueError("num_blocks does not divide embedding table size")
block_v_size = 2**int(z_size_per_residual / num_blocks)
if ema:
if ema_count is None:
raise ValueError("ema_count is None but ema is True")
if ema_means is None:
raise ValueError("ema_means is None but ema is True")
else:
block_v_size = None
with tf.variable_scope(
name, default_name="discrete_bottleneck", reuse=tf.AUTO_REUSE):
embed_fn = partial(
embed,
hidden_size=hidden_size,
z_size=z_size,
filter_size=filter_size,
bottleneck_kind=bottleneck_kind,
soft_em=soft_em,
num_blocks=num_blocks,
num_residuals=num_residuals,
block_v_size=block_v_size,
means=means,
name=name)
if bottleneck_kind == "dense":
# Note discrete output is continuous here.
outputs_discrete = tf.layers.dense(inputs, z_size, name="vcc")
outputs_dense = tf.layers.dense(
outputs_discrete, filter_size, name="vch1")
extra_loss = tf.constant(0.0)
neg_q_entropy = tf.constant(0.0)
elif bottleneck_kind in ["dvq", "gumbel-softmax-dvq"]:
inputs_3d = inputs
if len(inputs.shape) == 4:
inputs_3d = tf.squeeze(inputs, axis=2)
if reshape_method == "slice":
x_reshaped = slice_hidden(
inputs_3d, hidden_size=hidden_size, num_blocks=num_blocks)
elif reshape_method == "project":
if projection_tensors is None:
raise ValueError(
"Projection tensors is None for reshape_method project")
x_reshaped = project_hidden(
inputs_3d,
projection_tensors=projection_tensors,
hidden_size=hidden_size,
num_blocks=num_blocks)
else:
raise ValueError("Unknown reshape_method")
x_res = tf.reshape(x_reshaped,
[-1] + common_layers.shape_list(x_reshaped)[2:])
x_means_hot = []
x_means = 0
extra_loss = 0
for i in range(num_residuals):
x_means_hot_res, x_means_res, q_loss_res, e_loss_res, neg_q_entropy = (
embedding_lookup(
x_reshaped,
means=means[i],
num_blocks=num_blocks,
block_v_size=block_v_size,
bottleneck_kind=bottleneck_kind,
random_top_k=random_top_k,
soft_em=soft_em,
num_samples=num_samples,
temperature_warmup_steps=temperature_warmup_steps,
do_hard_gumbel_softmax=do_hard_gumbel_softmax,
num_flows=num_flows,
approximate_gs_entropy=approximate_gs_entropy,
sum_over_latents=sum_over_latents))
# Update the EMA variables.
if ema:
tf.logging.info("Using EMA with beta = {}".format(beta))
updated_ema_count_res = moving_averages.assign_moving_average(
ema_count[i],
tf.where(cond,
tf.reduce_sum(
tf.reshape(x_means_hot_res,
shape=[-1, num_blocks, block_v_size]),
axis=0), ema_count[i]),
decay,
zero_debias=False)
dw = tf.matmul(
tf.transpose(x_means_hot_res, perm=[1, 2, 0]),
tf.transpose(x_res, perm=[1, 0, 2]))
updated_ema_means_res = moving_averages.assign_moving_average(
ema_means[i], tf.where(cond, dw, ema_means[i]),
decay, zero_debias=False)
n = tf.reduce_sum(updated_ema_count_res, axis=-1, keep_dims=True)
updated_ema_count_res = (
(updated_ema_count_res + epsilon) / (n + 2**z_size * epsilon) * n)
# pylint: disable=g-no-augmented-assignment
updated_ema_means_res = updated_ema_means_res / tf.expand_dims(
updated_ema_count_res, axis=-1)
# pylint: enable=g-no-augmented-assignment
with tf.control_dependencies([e_loss_res]):
update_means_res = tf.assign(means[i],
tf.where(cond,
updated_ema_means_res,
means[i]))
with tf.control_dependencies([update_means_res]):
extra_loss += beta * e_loss_res
else:
extra_loss += q_loss_res + beta * e_loss_res
# Update the residuals.
x_res -= x_means_res
x_means += x_means_res
x_means_hot.append(x_means_hot_res)
# Get the discrete latent representation.
x_means_hot = tf.stack(x_means_hot, axis=1)
x_means_idx = tf.argmax(x_means_hot, axis=-1)
# Get the binary representation.
x_means_bits = int_to_bit(
x_means_idx,
num_bits=int(z_size / (num_residuals * num_blocks)),
base=2)
shape = common_layers.shape_list(x_means_bits)
new_shape = shape[:-2]
new_shape[-1] = z_size
x_means_bits = tf.reshape(x_means_bits, shape=new_shape)
outputs_discrete = bit_to_int(
tf.to_int32(x_means_bits), num_bits=z_size, base=2)
# Adjust shape of discrete outputs.
inputs_shape = common_layers.shape_list(inputs)
outputs_discrete = tf.reshape(outputs_discrete, inputs_shape[:-1])
# If we're using soft EM then set discretes to the hot representation.
if soft_em:
outputs_discrete = x_means_hot
outputs_discrete = tf.reshape(outputs_discrete,
inputs_shape[:-1] + [block_v_size])
# Reshape assuming hidden_size == inputs_shape[:-1].
x_means = tf.reshape(x_means, inputs_shape)
outputs_dense = inputs + tf.stop_gradient(x_means - inputs)
elif bottleneck_kind == "gumbel-softmax":
_, outputs_hot, extra_loss = gumbel_softmax(
inputs,
z_size=z_size,
mode=mode,
softmax_k=softmax_k,
temperature_warmup_steps=temperature_warmup_steps,
summary=summary,
name=name)
outputs_discrete = tf.argmax(outputs_hot, axis=-1)
outputs_dense = tf.layers.dense(
outputs_hot, hidden_size, name="dae_dense")
neg_q_entropy = tf.constant(0.0)
elif bottleneck_kind == "semhash":
outputs_discrete = tf.layers.dense(inputs, z_size, name="vcc")
y_clean = common_layers.saturating_sigmoid(outputs_discrete)
if summary:
tf.summary.histogram("y_clean", tf.reshape(y_clean, [-1]))
if noise_dev > 0 and mode == tf.estimator.ModeKeys.TRAIN:
noise = tf.truncated_normal(
common_layers.shape_list(outputs_discrete),
mean=0.0,
stddev=noise_dev)
y = common_layers.saturating_sigmoid(outputs_discrete + noise)
else:
y = y_clean
d = tf.to_float(tf.less(0.5, y))
y_discrete = tf.stop_gradient(d) + y - tf.stop_gradient(y)
pd = common_layers.inverse_exp_decay(startup_steps * 2)
pd *= discrete_mix
pd = pd if mode == tf.estimator.ModeKeys.TRAIN else 1.0
c = tf.where(
tf.less(tf.random_uniform([common_layers.shape_list(y)[0]]), pd),
y_discrete, y)
outputs_dense_a = tf.layers.dense(c, filter_size, name="vch1a")
outputs_dense_b = tf.layers.dense(1.0 - c, filter_size, name="vch1b")
outputs_dense = outputs_dense_a + outputs_dense_b
dx = tf.to_int32(tf.stop_gradient(d))
outputs_discrete = bit_to_int(dx, z_size)
extra_loss = tf.constant(0.0)
neg_q_entropy = tf.constant(0.0)
elif bottleneck_kind == "vae":
outputs_discrete, extra_loss, _, _ = vae(inputs, z_size, name="vae")
outputs_dense = tf.layers.dense(
outputs_discrete, filter_size, name="vch1")
neg_q_entropy = tf.constant(0.0)
else:
raise ValueError("Unknown discretization method.")
return outputs_dense, outputs_discrete, extra_loss, embed_fn, neg_q_entropy | [
"Discretization bottleneck.\n\n Args:\n inputs: Input to the bottleneck, a Tensor of shape [..., channels].\n hidden_size: Dimension of the dense output.\n z_size: Number of bits, where discrete codes range from 1 to 2**z_size.\n filter_size: Filter size in the embedding function.\n mode: tf.estimator.ModeKeys.\n bottleneck_kind: Kind of discretization bottleneck. One of dense, dvq\n (decomposed vector quantization), gumbel-softmax, gumbel-softmax-dvq,\n semhash, or vae.\n num_blocks: Number of blocks. Used only if bottleneck_kind is DVQ.\n num_residuals: Number of residual units used to compute nearest\n neighbors. Used only if bottleneck_kind is DVQ.\n reshape_method: Method to reshape. Used only if bottleneck_kind is DVQ.\n projection_tensors: If the reshape method is project, then these are the\n tensors used to project.\n beta: Scale factor for codebook loss and EMA. Used only if bottleneck_kind\n is DVQ.\n ema: Whether to update embeddings using exponential moving averages. Used\n only if bottleneck_kind is DVQ.\n means: The embedding table. Used only if ema is True.\n ema_count: Table of counts for each embedding corresponding to how many\n examples in a batch it was the closest to. Used only if ema is True.\n ema_means: Exponentially averaged version of the embeddings. Used only if\n ema is True.\n epsilon: Small value to avoid dividing by zero in EMA update. Used only if\n ema is True.\n decay: Decay factor for the exponential moving average. Used only if ema is\n True.\n random_top_k: Noisy top-k. Used only if bottleneck_kind is DVQ.\n soft_em: Whether to use soft EM or hard EM. Used only if bottleneck_kind is\n DVQ.\n num_samples: Number of samples for soft EM. Used only if soft_em is True.\n softmax_k: If > 0 then do top-k softmax. Used only if bottleneck_kind\n is gumbel-softmax.\n temperature_warmup_steps: Number of steps it takes to decay temperature to\n 0. Used only if bottleneck_kind is gumbel-softmax or gumbel-softmax-dvq.\n do_hard_gumbel_softmax: Whether to use hard or soft Gumbel-Softmax\n samples. Used only if bottleneck_kind is gumbel-softmax-dvq.\n num_flows: Number of inverse autoregresive flows. Used only if\n bottleneck_kind is gumbel-softmax-dvq.\n approximate_gs_entropy: Whether to approximate the Gumbel-Softmax density\n as a categorical distribution when calculating the sample entropy. Used\n only if bottleneck_kind is gumbel-softmax-dvq.\n sum_over_latents: Whether to sum over all non-batch dimensions before\n taking mean of entropy loss term. Used only if bottleneck kind is DVQ\n or gumbel-softmax-dvq.\n discrete_mix: Factor for mixing discrete and non-discrete input. Used only\n if bottleneck_kind is semhash.\n noise_dev: Noise stddev. Used only if bottleneck_kind is semhash.\n startup_steps: Number of steps after which latent predictor is trained. Used\n only if bottleneck_kind is semhash.\n summary: Whether to write summaries.\n name: Name for the bottleneck scope.\n cond: A tf.bool condition on whether to update the codebook.\n\n Returns:\n outputs_dense: Tensor of shape [..., output_dim]. The output dimension is\n hidden_size if bottleneck_kind is gumbel-softmax, DVQ; filter_size if\n bottleneck_kind is dense, semhash, vae. If bottleneck_kind is DVQ,\n outputs_dense represents the codebook (means) indexed by outputs_discrete.\n outputs_discrete: Tensor of shape [...]. Discrete codes, each an index in\n [0, 2**z_size). It uses the hot representation if soft_em is True.\n extra_loss: Scalar Tensor. Sum of codebook and commitment losses if\n bottleneck_kind is DVQ; else zero.\n embed_fn: Function embed with arguments partially filled in.\n neg_q_entropy: Scalar Tensor representing negative entropy of variational\n approximation (0 if it is deterministic).\n\n Raises:\n ValueError: If projection_tensors is None for reshape_method project, or\n ema_count or ema_means is None if ema is True, or unknown args.\n "
] |
Please provide a description of the function:def predict_bits_with_lstm(prediction_source, state_size, total_num_bits,
target_bits=None, extra_inputs=None,
bits_at_once=8, temperature=1.0, dropout=0.1):
with tf.variable_scope("predict_bits_with_lstm"):
# Layers and cell state creation.
lstm_cell = tf.nn.rnn_cell.LSTMCell(state_size)
discrete_predict = tf.layers.Dense(2**bits_at_once, name="discrete_predict")
discrete_embed = tf.layers.Dense(state_size, name="discrete_embed")
batch_size = common_layers.shape_list(prediction_source)[0]
layer_pred = tf.layers.flatten(prediction_source)
first_lstm_input = tf.layers.dense(layer_pred, state_size, name="istate")
c_state = tf.layers.dense(layer_pred, state_size, name="cstate")
m_state = tf.layers.dense(layer_pred, state_size, name="mstate")
state = (c_state, m_state)
# Prediction mode if no targets are given.
if target_bits is None:
outputs = []
lstm_input = first_lstm_input
for i in range(total_num_bits // bits_at_once):
if extra_inputs is not None:
lstm_input = tf.concat([lstm_input, extra_inputs[:, i, :]], axis=1)
output, state = lstm_cell(lstm_input, state)
discrete_logits = discrete_predict(output)
discrete_samples = common_layers.sample_with_temperature(
discrete_logits, temperature)
outputs.append(tf.expand_dims(discrete_samples, axis=1))
lstm_input = discrete_embed(tf.one_hot(discrete_samples, 256))
outputs = tf.concat(outputs, axis=1)
outputs = int_to_bit(outputs, bits_at_once)
outputs = tf.reshape(outputs, [batch_size, total_num_bits])
return 2 * outputs - 1, 0.0
# Training mode, calculating loss.
assert total_num_bits % bits_at_once == 0
target_bits = tf.reshape(tf.maximum(tf.stop_gradient(target_bits), 0), [
batch_size, total_num_bits // bits_at_once, bits_at_once])
target_ints = bit_to_int(target_bits, bits_at_once)
tf.summary.histogram("target_integers", tf.reshape(target_ints, [-1]))
target_hot = tf.one_hot(target_ints, 2**bits_at_once, axis=-1)
target_embedded = discrete_embed(target_hot)
target_embedded = tf.nn.dropout(target_embedded, 1.0 - dropout)
teacher_input = tf.concat(
[tf.expand_dims(first_lstm_input, axis=1), target_embedded], axis=1)
outputs = []
for i in range(total_num_bits // bits_at_once):
lstm_input = teacher_input[:, i, :]
if extra_inputs is not None:
lstm_input = tf.concat([lstm_input, extra_inputs[:, i, :]], axis=1)
output, state = lstm_cell(lstm_input, state)
outputs.append(tf.expand_dims(output, axis=1))
outputs = tf.concat(outputs, axis=1)
outputs = tf.nn.dropout(outputs, 1.0 - dropout)
d_int_pred = discrete_predict(outputs)
pred_loss = tf.losses.sparse_softmax_cross_entropy(
logits=d_int_pred, labels=target_ints)
pred_loss = tf.reduce_mean(pred_loss)
return d_int_pred, pred_loss | [
"Predict a sequence of bits (a latent) with LSTM, both training and infer.\n\n Given a tensor on which the predictions are based (prediction_source), we use\n a single-layer LSTM with state of size state_size to predict total_num_bits,\n which we predict in groups of size bits_at_once. During training, we use\n target_bits as input to the LSTM (teacher forcing) and return the target_bits\n together with the prediction loss. During inference, we sample with the given\n temperature and return the predicted sequence and loss 0.\n\n Args:\n prediction_source: a Tensor of shape [batch_size, ...] used to create\n the initial state and the first input to the LSTM.\n state_size: python integer, the size of the LSTM state.\n total_num_bits: python integer, how many bits in total to predict.\n target_bits: a tensor of shape [batch_size, total_num_bits] used during\n training as the target to predict; each element should be -1 or 1.\n extra_inputs: a Tensor [batch_size, total_num_bits // bits_at_once, d]\n of additional inputs, passed as additional LSTM inputs.\n bits_at_once: pytho integer, how many bits to predict at once.\n temperature: python float, temperature used for sampling during inference.\n dropout: float, the amount of dropout to aply during training (0.1 default).\n\n Returns:\n a pair (bits, loss) with the predicted bit sequence, which is a Tensor of\n shape [batch_size, total_num_bits] with elements either -1 or 1, and a loss\n used to train the predictions against the provided target_bits.\n "
] |
Please provide a description of the function:def get_vq_codebook(codebook_size, hidden_size):
with tf.variable_scope("vq", reuse=tf.AUTO_REUSE):
means = tf.get_variable(
name="means",
shape=[codebook_size, hidden_size],
initializer=tf.uniform_unit_scaling_initializer())
ema_count = tf.get_variable(
name="ema_count",
shape=[codebook_size],
initializer=tf.constant_initializer(0),
trainable=False)
with tf.colocate_with(means):
ema_means = tf.get_variable(
name="ema_means",
initializer=means.initialized_value(),
trainable=False)
return means, ema_means, ema_count | [
"Get lookup table for VQ bottleneck."
] |
Please provide a description of the function:def vq_nearest_neighbor(x, means,
soft_em=False, num_samples=10, temperature=None):
bottleneck_size = common_layers.shape_list(means)[0]
x_norm_sq = tf.reduce_sum(tf.square(x), axis=-1, keepdims=True)
means_norm_sq = tf.reduce_sum(tf.square(means), axis=-1, keepdims=True)
scalar_prod = tf.matmul(x, means, transpose_b=True)
dist = x_norm_sq + tf.transpose(means_norm_sq) - 2 * scalar_prod
if soft_em:
x_means_idx = tf.multinomial(-dist, num_samples=num_samples)
x_means_hot = tf.one_hot(
x_means_idx, depth=common_layers.shape_list(means)[0])
x_means_hot = tf.reduce_mean(x_means_hot, axis=1)
else:
if temperature is None:
x_means_idx = tf.argmax(-dist, axis=-1)
else:
x_means_idx = tf.multinomial(- dist / temperature, 1)
x_means_idx = tf.squeeze(x_means_idx, axis=-1)
if (common_layers.should_generate_summaries() and
not common_layers.is_xla_compiled()):
tf.summary.histogram("means_idx", tf.reshape(x_means_idx, [-1]))
x_means_hot = tf.one_hot(x_means_idx, bottleneck_size)
x_means_hot_flat = tf.reshape(x_means_hot, [-1, bottleneck_size])
x_means = tf.matmul(x_means_hot_flat, means)
e_loss = tf.reduce_mean(tf.squared_difference(x, tf.stop_gradient(x_means)))
return x_means_hot, e_loss, dist | [
"Find the nearest element in means to elements in x."
] |
Please provide a description of the function:def vq_discrete_bottleneck(x,
bottleneck_bits,
beta=0.25,
decay=0.999,
epsilon=1e-5,
soft_em=False,
num_samples=10):
bottleneck_size = 2**bottleneck_bits
x_means_hot, e_loss, _ = vq_body(
x,
bottleneck_size,
beta=beta,
decay=decay,
epsilon=epsilon,
soft_em=soft_em,
num_samples=num_samples)
return x_means_hot, e_loss | [
"Simple vector quantized discrete bottleneck."
] |
Please provide a description of the function:def vq_body(x,
codebook_size,
beta=0.25,
decay=0.999,
epsilon=1e-5,
soft_em=False,
num_samples=10,
temperature=None,
do_update=True):
x_shape = common_layers.shape_list(x)
hidden_size = x_shape[-1]
means, ema_means, ema_count = get_vq_codebook(codebook_size, hidden_size)
x = tf.reshape(x, [-1, hidden_size])
x_means_hot, e_loss, distances = vq_nearest_neighbor(
x, means, soft_em=soft_em, num_samples=num_samples,
temperature=temperature)
def loss_with_update():
updated_ema_count = moving_averages.assign_moving_average(
ema_count,
tf.reduce_sum(tf.reshape(x_means_hot, shape=[-1, codebook_size]),
axis=0),
decay,
zero_debias=False)
dw = tf.matmul(x_means_hot, x, transpose_a=True)
updated_ema_means = tf.identity(
moving_averages.assign_moving_average(
ema_means, dw, decay, zero_debias=False))
n = tf.reduce_sum(updated_ema_count, axis=-1, keepdims=True)
updated_ema_count = (
(updated_ema_count + epsilon) / (n + codebook_size * epsilon) * n)
updated_ema_means /= tf.expand_dims(updated_ema_count, axis=-1)
with tf.control_dependencies([e_loss]):
update_means = means.assign(updated_ema_means)
with tf.control_dependencies([update_means]):
return beta * e_loss
# Loss, also do update if requested.
if do_update:
loss = loss_with_update()
else:
loss = tf.cond(do_update, loss_with_update, lambda: beta * e_loss)
d = tf.reshape(x_means_hot, x_shape[:-1] + [codebook_size])
return d, loss, distances | [
"Discretize each x into one of codebook_size codes.",
"Update the ema variables and return loss triggering the update."
] |
Please provide a description of the function:def vq_loss(x,
targets,
codebook_size,
beta=0.25,
decay=0.999,
epsilon=1e-5,
soft_em=False,
num_samples=10,
temperature=None,
do_update=True):
x_shape = common_layers.shape_list(x)
target_shape = common_layers.shape_list(targets)
hidden_size = x_shape[-1]
means, _, _ = get_vq_codebook(codebook_size, hidden_size)
x = tf.reshape(x, [-1, hidden_size])
targets = tf.reshape(targets, [-1])
one_hot_targets = tf.one_hot(targets, codebook_size)
target_means = tf.matmul(one_hot_targets, means)
discrete_x, code_loss, distances = vq_body(
x,
codebook_size,
beta=beta,
decay=decay,
epsilon=epsilon,
soft_em=soft_em,
num_samples=num_samples,
temperature=temperature,
do_update=do_update)
logits = -distances
targets_loss = tf.losses.sparse_softmax_cross_entropy(
logits=logits, labels=targets)
targets_loss = tf.reduce_mean(targets_loss)
x_means = tf.matmul(discrete_x, means)
x_means = x + tf.stop_gradient(x_means - x)
discrete_x = tf.reshape(discrete_x, x_shape[:-1] + [codebook_size])
target_means = tf.reshape(target_means, target_shape + [hidden_size])
return discrete_x, x_means, target_means, code_loss, targets_loss | [
"Compute the loss of large vocab tensors using a VQAE codebook.\n\n Args:\n x: Tensor of inputs to be quantized to nearest code\n targets: Tensor of target indices to target codes\n codebook_size: Size of quantization codebook\n beta: scalar float for moving averages\n decay: scalar float for moving averages\n epsilon: scalar float for moving averages\n soft_em: boolean, whether to apply a soft sampling procedure\n num_samples: if soft_em, number of samples to take\n temperature: temperature if we want to sample nearest neighbors or None\n do_update: whether to update the means; True by default, can be a Tensor\n\n Returns:\n discrete_x: one-hot Tensor indicating which codebook element is closest to x\n x_means: Tensor, on the forward pass: closest codebook element to x, on the\n backwards pass: soft convex-combination of codebook elements by proximity\n to x\n target_means: the codebook elements corresponding to the targets\n code_loss: loss driving x closer to its nearest codebook element\n targets_loss: cross-entropy loss driving x closer to code corresponding to\n target\n "
] |
Please provide a description of the function:def vq_discrete_unbottleneck(x, hidden_size):
x_shape = common_layers.shape_list(x)
x = tf.to_float(x)
bottleneck_size = common_layers.shape_list(x)[-1]
means, _, _ = get_vq_codebook(bottleneck_size, hidden_size)
result = tf.matmul(tf.reshape(x, [-1, x_shape[-1]]), means)
return tf.reshape(result, x_shape[:-1] + [hidden_size]) | [
"Simple undiscretization from vector quantized representation."
] |
Please provide a description of the function:def gumbel_softmax_nearest_neighbor_dvq(x,
means,
block_v_size,
hard=False,
temperature_init=1.2,
num_samples=1,
temperature_warmup_steps=150000,
summary=True,
num_flows=0,
approximate_gs_entropy=False,
sum_over_latents=False):
batch_size, latent_dim, num_blocks, block_dim = common_layers.shape_list(x)
# Combine latent_dim and batch_size for computing distances.
x = tf.reshape(x, [-1, num_blocks, block_dim])
# Compute distances using (x - means)**2 = x**2 + means**2 - 2*x*means.
x_norm_sq = tf.reduce_sum(tf.square(x), axis=-1, keepdims=True)
means_norm_sq = tf.reduce_sum(tf.square(means), axis=-1, keepdims=True)
means_norm_sq = tf.transpose(means_norm_sq, perm=[2, 0, 1])
scalar_prod = tf.matmul(
tf.transpose(x, perm=[1, 0, 2]), tf.transpose(means, perm=[0, 2, 1]))
scalar_prod = tf.transpose(scalar_prod, perm=[1, 0, 2])
dist = x_norm_sq + means_norm_sq - 2 * scalar_prod
# IAF requires latents to have their own dimension, so reshape dist from
# [batch_size * latent_dim, num_blocks, block_v_size] to
# [batch_size * num_blocks, latent_dim, block_v_size].
dist = tf.reshape(dist, [batch_size, latent_dim, num_blocks, -1])
dist = tf.reshape(
tf.transpose(dist, perm=[0, 2, 1, 3]), [-1, latent_dim, block_v_size])
log_class_probs = tf.nn.log_softmax(-dist)
sample_shape = [num_samples] + common_layers.shape_list(dist)
gumbel_samples = gumbel_sample(sample_shape)
# Temperature decays linearly.
temperature = temperature_init - common_layers.inverse_lin_decay(
temperature_warmup_steps)
# 10% of the time keep reasonably high temperature to keep learning.
temperature = tf.cond(
tf.less(tf.random_uniform([]), 0.9), lambda: temperature,
lambda: tf.random_uniform([], minval=0.5, maxval=1.0))
gumbel_softmax_samples = tf.nn.softmax(
(tf.expand_dims(log_class_probs, 0) + gumbel_samples) / temperature)
q_samples = tf.clip_by_value(gumbel_softmax_samples, 1e-6, 1 - 1e-6)
if approximate_gs_entropy:
q_dist = tfp.distributions.Multinomial(total_count=1.0, logits=-dist)
else:
q_dist = tfp.distributions.RelaxedOneHotCategorical(
temperature, logits=-dist)
# Take mean over samples to approximate entropy.
neg_q_entropy = tf.reduce_mean(q_dist.log_prob(q_samples), 0)
if summary:
tf.summary.histogram("neg_q_entropy", tf.reshape(neg_q_entropy, [-1]))
if sum_over_latents:
neg_q_entropy = tf.reshape(neg_q_entropy,
[batch_size, num_blocks, latent_dim])
neg_q_entropy = tf.reduce_sum(neg_q_entropy, [1, 2])
neg_q_entropy = tf.reduce_mean(neg_q_entropy)
if num_flows > 0:
hparams = iaf_hparams(hidden_size=512, filter_size=4096)
q_samples = tf.reshape(q_samples, [-1, latent_dim, block_v_size])
for flow in range(num_flows):
shifted_samples = tf.pad(q_samples, [[0, 0], [1, 0], [0, 0]])[:, :-1, :]
# Project samples from [batch_size, latent_size, block_v_size] to
# [batch_size, latent_size, hidden_size].
shifted_samples = common_layers.dense(shifted_samples,
hparams.hidden_size)
# TODO(vafa): Include masking as a flag.
mask = True
if mask:
attention_type = cia.AttentionType.LOCAL_1D
else:
attention_type = cia.AttentionType.GLOBAL
ffn_output = cia.transformer_decoder_layers(
inputs=shifted_samples,
encoder_output=None,
num_layers=6,
hparams=hparams,
attention_type=attention_type,
name="transformer_" + str(flow))
# Project samples back to [batch_size, latent_size, block_v_size].
ffn_output = common_layers.dense(ffn_output, block_v_size)
log_pi = tf.nn.log_softmax(ffn_output)
# Flow 1: Adding log_pi to q_samples and dividing by the temperature.
# Note that we drop the last dimension of q_samples for centered-softmax,
# which we can do without recalculating probabilities because the last
# dimension of log_pi and q_samples are deterministic given the others.
# Flow 2: Centered-softmax.
chained_bijectors = tfp.bijectors.Chain([
tfp.bijectors.SoftmaxCentered(),
tfp.bijectors.Affine(
shift=log_pi[:, :, :-1],
scale_identity_multiplier=1. / temperature)
])
q_samples = chained_bijectors.forward(q_samples[:, :, :-1])
log_det = chained_bijectors.inverse_log_det_jacobian(
q_samples, event_ndims=1)
log_det = tf.reshape(log_det,
[num_samples, batch_size, num_blocks, latent_dim])
if sum_over_latents:
log_det = tf.reduce_sum(log_det, axis=[2, 3])
neg_q_entropy += tf.reduce_mean(log_det)
q_samples = tf.reshape(
q_samples,
[num_samples, batch_size * num_blocks, latent_dim, block_v_size])
if hard:
x_means_idx = tf.argmax(q_samples, -1)
# Take average of one-hot vectors over samples.
x_means_hot = tf.reduce_mean(tf.one_hot(x_means_idx, block_v_size), 0)
x_means_assignments = (
tf.reduce_mean(q_samples, 0) +
tf.stop_gradient(x_means_hot - tf.reduce_mean(q_samples, 0)))
else:
x_means_assignments = tf.reduce_mean(gumbel_softmax_samples, 0)
# Reshape assignments to [batch_size * latent_dim, num_blocks,
# block_v_size]. We have to transpose between reshapes to make sure the
# dimensions have the correct interpretation.
x_means_assignments = tf.reshape(
x_means_assignments, [batch_size, num_blocks, latent_dim, block_v_size])
x_means_assignments = tf.transpose(x_means_assignments, [0, 2, 1, 3])
x_means_assignments = tf.reshape(
x_means_assignments, [batch_size * latent_dim, num_blocks, block_v_size])
return x_means_assignments, neg_q_entropy | [
"Sample from Gumbel-Softmax and compute neighbors and losses.\n\n Args:\n x: A `float`-like `Tensor` of shape [batch_size, latent_dim, num_blocks,\n block_dim] containing the latent vectors to be compared to the codebook.\n means: Embedding table of shape [num_blocks, block_v_size, block_dim].\n block_v_size: Number of discrete codes per block.\n hard: Determines whether we take hard or soft Gumbel-Softmax samples\n (Default: False).\n temperature_init: Initial temperature used for Gumbel-Softmax samples,\n after it which it decays to 0 (Default: 1.2).\n num_samples: Number of samples drawn for each latent (Default: 1).\n temperature_warmup_steps: Number of steps it takes to decay temperature to 0\n (Default: 150000).\n summary: When `True`, we save histogram summaries of the KL term (Default:\n True).\n num_flows: Number of inverse autoregressive flows with Gumbel-Softmax\n samples.\n approximate_gs_entropy: When `True`, we approximate Gumbel-Softmax\n density as categorical when calculating sample entropy (Default: False).\n sum_over_latents: Whether to sum over non-batch dimensions when calculating\n negative entropy loss.\n\n Returns:\n x_means_assignments: A `float`-like `Tensor` containing the codebook\n assignments, averaged over samples, with shape [batch_size * latent_dim,\n num_blocks, block_v_size].\n neg_q_entropy: The negative entropy of the variational distribution,\n averaged over samples.\n "
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.