Code stringlengths 103 85.9k | Summary listlengths 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 o... | [
"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.optimizat... | [
"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_epo... | [
"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.... | [
"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_hpa... | [
"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... | [
"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_rewar... | [
"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]
# ... | [
"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... | [
"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)
ret... | [
"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... | [
"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)
hpara... | [
"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_mea... | [
"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,],
... | [
"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,
... | [
"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_depe... | [
"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 * sqr... | [
"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... | [
"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... | [
"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_varia... | [
"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"... | [
"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 r... |
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_w... | [
"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... |
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,
gr... | [
"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.app... |
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 ... | [
"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]... | [
"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
h... | [
"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_fi... | [
"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_pa... | [
"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, indicati... |
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)
... | [
"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... | [
"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) ... | [
"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 ... | [
"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)
retur... | [
"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 -... | [
"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... | [
"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... | [
"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 ... | [
"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_p... | [
"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
dim... | [
"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 '
... | [
"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: expecte... | [
"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):
... | [
"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_... | [
"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... | [
"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:\... |
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=redefine... | [
"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]... | [
"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._bu... | [
"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(a... | [
"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 +... | [
"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.... | [
"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 ea... | [
"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_n... | [
"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 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... | [
"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.... | [
"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(",")
#... | [
"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 ... |
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.l... | [
"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_... | [
"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 th... |
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:
... | [
"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]):
croppe... | [
"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.\... |
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),
... | [
"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... |
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_r... | [
"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, s... | [
"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)
retur... | [
"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_si... | [
"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, [... | [
"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=2... | [
"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 ... |
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",
... | [
"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: t... |
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, -... | [
"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 ... |
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].\... |
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)... | [
"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... |
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,
... | [
"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: 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... | [
"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 nu... |
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... | [
"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.var... | [
"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 onl... |
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],... | [
"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="gumbe... | [
"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 t... |
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,
... | [
"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.estimat... |
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"):
# L... | [
"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 ... |
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 =... | [
"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(m... | [
"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=1... | [
"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)
... | [
"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_la... | [
"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... |
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]... | [
"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,
... | [
"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 bloc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.