project_name stringlengths 6 104 | file_name stringlengths 4 89 | full_name stringlengths 1 102 | func_name stringlengths 1 85 | docstring stringlengths 13 836 | docstring_tokens listlengths 4 122 | code stringlengths 23 39.7k | code_tokens stringlengths 29 44.6k | url int64 3 986k |
|---|---|---|---|---|---|---|---|---|
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | image_transformer_2d.py | img2img_transformer2d_q3 | img2img_transformer2d_q3 | Current best hparams for local 2d. | [
"Current",
"best",
"hparams",
"for",
"local",
"2d."
] | def img2img_transformer2d_q3():
hparams = img2img_transformer2d_q1()
hparams.batch_size = 2
hparams.query_shape = (8, 16)
hparams.memory_flange = (8, 32)
return hparams | ['def', 'img2img_transformer2d_q3():', 'hparams', '=', 'img2img_transformer2d_q1()', 'hparams.batch_size', '=', '2', 'hparams.query_shape', '=', '(8,', '16)', 'hparams.memory_flange', '=', '(8,', '32)', 'return', 'hparams'] | 965,635 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | image_transformer_2d.py | img2img_transformer_b3 | img2img_transformer_b3 | Current best hparams for local 1d. | [
"Current",
"best",
"hparams",
"for",
"local",
"1d."
] | def img2img_transformer_b3():
hparams = img2img_transformer_base()
hparams.batch_size = 2
hparams.layer_preprocess_sequence = 'none'
hparams.layer_postprocess_sequence = 'dan'
hparams.block_length = 128
hparams.sampling_temp = 0.9
return hparams | ['def', 'img2img_transformer_b3():', 'hparams', '=', 'img2img_transformer_base()', 'hparams.batch_size', '=', '2', 'hparams.layer_preprocess_sequence', '=', "'none'", 'hparams.layer_postprocess_sequence', '=', "'dan'", 'hparams.block_length', '=', '128', 'hparams.sampling_temp', '=', '0.9', 'return', 'hparams'] | 965,637 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | image_transformer_2d.py | img2img_transformer_base_tpu | img2img_transformer_base_tpu | Hparams for training img2img_transformer on tpu. | [
"Hparams",
"for",
"training",
"img2img_transformer",
"on",
"tpu."
] | def img2img_transformer_base_tpu():
hparams = img2img_transformer_base()
update_hparams_for_tpu(hparams)
hparams.batch_size = 2
hparams.num_heads = 4
hparams.num_decoder_layers = 8
hparams.num_encoder_layers = 4
hparams.shared_embedding_and_softmax_weights = False
return hparams | ['def', 'img2img_transformer_base_tpu():', 'hparams', '=', 'img2img_transformer_base()', 'update_hparams_for_tpu(hparams)', 'hparams.batch_size', '=', '2', 'hparams.num_heads', '=', '4', 'hparams.num_decoder_layers', '=', '8', 'hparams.num_encoder_layers', '=', '4', 'hparams.shared_embedding_and_softmax_weights', '=', ... | 965,638 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | image_transformer_2d.py | img2img_transformer2d_n103 | img2img_transformer2d_n103 | Best config for img2img. | [
"Best",
"config",
"for",
"img2img."
] | def img2img_transformer2d_n103():
hparams = img2img_transformer2d_base()
hparams.batch_size = 1
hparams.num_decoder_layers = 12
hparams.num_encoder_layers = 6
hparams.query_shape = (8, 32)
hparams.memory_flange = (8, 64)
hparams.layer_prepostprocess_dropout = 0.1
return hparams | ['def', 'img2img_transformer2d_n103():', 'hparams', '=', 'img2img_transformer2d_base()', 'hparams.batch_size', '=', '1', 'hparams.num_decoder_layers', '=', '12', 'hparams.num_encoder_layers', '=', '6', 'hparams.query_shape', '=', '(8,', '32)', 'hparams.memory_flange', '=', '(8,', '64)', 'hparams.layer_prepostprocess_dr... | 965,639 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | lstm.py | lstm_seq2seq_internal_bid_encoder | lstm_seq2seq_internal_bid_encoder | The basic LSTM seq2seq model with bidirectional encoder. | [
"The",
"basic",
"LSTM",
"seq2seq",
"model",
"with",
"bidirectional",
"encoder."
] | def lstm_seq2seq_internal_bid_encoder(inputs, targets, hparams, train):
with tf.variable_scope('lstm_seq2seq_bid_encoder'):
if inputs is not None:
inputs_length = common_layers.length_from_embedding(inputs)
inputs = common_layers.flatten4d3d(inputs)
(_, final_encoder_stat... | ['def', 'lstm_seq2seq_internal_bid_encoder(inputs,', 'targets,', 'hparams,', 'train):', 'with', "tf.variable_scope('lstm_seq2seq_bid_encoder'):", 'if', 'inputs', 'is', 'not', 'None:', 'inputs_length', '=', 'common_layers.length_from_embedding(inputs)', 'inputs', '=', 'common_layers.flatten4d3d(inputs)', '(_,', 'final_e... | 965,645 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | f | f | Applies residual function for RevNet. | [
"Applies",
"residual",
"function",
"for",
"RevNet."
] | def f(x, depth1, depth2, dim='2d', first_batch_norm=True, stride=1, training=True, bottleneck=True, padding='SAME'):
conv = CONFIG[dim]['conv']
with tf.variable_scope('f'):
if first_batch_norm:
net = tf.layers.batch_normalization(x, training=training)
net = tf.nn.relu(net)
... | ['def', 'f(x,', 'depth1,', 'depth2,', "dim='2d',", 'first_batch_norm=True,', 'stride=1,', 'training=True,', 'bottleneck=True,', "padding='SAME'):", 'conv', '=', "CONFIG[dim]['conv']", 'with', "tf.variable_scope('f'):", 'if', 'first_batch_norm:', 'net', '=', 'tf.layers.batch_normalization(x,', 'training=training)', 'net... | 965,658 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | downsample_bottleneck | downsample_bottleneck | Downsamples 'x' by `stride` using a 1x1 convolution filter. | [
"Downsamples",
"'x'",
"by",
"`stride`",
"using",
"a",
"1x1",
"convolution",
"filter."
] | def downsample_bottleneck(x, output_channels, dim='2d', stride=1, scope='h'):
conv = CONFIG[dim]['conv']
with tf.variable_scope(scope):
x = conv(x, output_channels, 1, strides=stride, padding='SAME', activation=None)
return x | ['def', 'downsample_bottleneck(x,', 'output_channels,', "dim='2d',", 'stride=1,', "scope='h'):", 'conv', '=', "CONFIG[dim]['conv']", 'with', 'tf.variable_scope(scope):', 'x', '=', 'conv(x,', 'output_channels,', '1,', 'strides=stride,', "padding='SAME',", 'activation=None)', 'return', 'x'] | 965,659 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | downsample_residual | downsample_residual | Downsamples 'x' by `stride` using average pooling. | [
"Downsamples",
"'x'",
"by",
"`stride`",
"using",
"average",
"pooling."
] | def downsample_residual(x, output_channels, dim='2d', stride=1, scope='h'):
with tf.variable_scope(scope):
if stride > 1:
avg_pool = CONFIG[dim]['avg_pool']
x = avg_pool(x, pool_size=(stride, stride), strides=(stride, stride), padding='VALID')
input_channels = tf.shape(x)[3]
... | ['def', 'downsample_residual(x,', 'output_channels,', "dim='2d',", 'stride=1,', "scope='h'):", 'with', 'tf.variable_scope(scope):', 'if', 'stride', '>', '1:', 'avg_pool', '=', "CONFIG[dim]['avg_pool']", 'x', '=', 'avg_pool(x,', 'pool_size=(stride,', 'stride),', 'strides=(stride,', 'stride),', "padding='VALID')", 'input... | 965,660 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | unit | unit | Implements bottleneck RevNet unit from authors' RevNet architecture. | [
"Implements",
"bottleneck",
"RevNet",
"unit",
"from",
"authors'",
"RevNet",
"architecture."
] | def unit(x1, x2, block_num, depth, num_layers, dim='2d', bottleneck=True, first_batch_norm=True, stride=1, training=True):
scope_name = 'unit_%d' % block_num
if bottleneck:
depth1 = depth
depth2 = depth * 4
else:
depth1 = depth2 = depth
residual = wrapped_partial(f, depth1=depth1... | ['def', 'unit(x1,', 'x2,', 'block_num,', 'depth,', 'num_layers,', "dim='2d',", 'bottleneck=True,', 'first_batch_norm=True,', 'stride=1,', 'training=True):', 'scope_name', '=', "'unit_%d'", '%', 'block_num', 'if', 'bottleneck:', 'depth1', '=', 'depth', 'depth2', '=', 'depth', '*', '4', 'else:', 'depth1', '=', 'depth2', ... | 965,662 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | final_block | final_block | Converts activations from last RevNet block to pre-logits. | [
"Converts",
"activations",
"from",
"last",
"RevNet",
"block",
"to",
"pre-logits."
] | def final_block(x1, x2, dim='2d', training=True, scope='final_block'):
with tf.variable_scope(scope):
y = tf.concat([x1, x2], axis=CONFIG[dim]['split_axis'])
y = tf.layers.batch_normalization(y, training=training)
y = tf.nn.relu(y)
net = tf.reduce_mean(y, CONFIG[dim]['reduction_dimen... | ['def', 'final_block(x1,', 'x2,', "dim='2d',", 'training=True,', "scope='final_block'):", 'with', 'tf.variable_scope(scope):', 'y', '=', 'tf.concat([x1,', 'x2],', "axis=CONFIG[dim]['split_axis'])", 'y', '=', 'tf.layers.batch_normalization(y,', 'training=training)', 'y', '=', 'tf.nn.relu(y)', 'net', '=', 'tf.reduce_mean... | 965,663 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | revnet | revnet | Uses Tensor2Tensor memory optimized RevNet block to build a RevNet. | [
"Uses",
"Tensor2Tensor",
"memory",
"optimized",
"RevNet",
"block",
"to",
"build",
"a",
"RevNet."
] | def revnet(inputs, hparams, reuse=None):
training = hparams.mode == tf.estimator.ModeKeys.TRAIN
with tf.variable_scope('RevNet', reuse=reuse):
(x1, x2) = init(inputs, num_channels=hparams.num_channels_init_block, dim=hparams.dim, kernel_size=hparams.init_kernel_size, maxpool=hparams.init_maxpool, stride... | ['def', 'revnet(inputs,', 'hparams,', 'reuse=None):', 'training', '=', 'hparams.mode', '==', 'tf.estimator.ModeKeys.TRAIN', 'with', "tf.variable_scope('RevNet',", 'reuse=reuse):', '(x1,', 'x2)', '=', 'init(inputs,', 'num_channels=hparams.num_channels_init_block,', 'dim=hparams.dim,', 'kernel_size=hparams.init_kernel_si... | 965,664 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | revnet_base | revnet_base | Default hparams for Revnet. | [
"Default",
"hparams",
"for",
"Revnet."
] | def revnet_base():
hparams = common_hparams.basic_params1()
hparams.add_hparam('num_channels', [64, 128, 256, 416])
hparams.add_hparam('num_layers_per_block', [1, 1, 10, 1])
hparams.add_hparam('bottleneck', True)
hparams.add_hparam('first_batch_norm', [False, True, True, True])
hparams.add_hpara... | ['def', 'revnet_base():', 'hparams', '=', 'common_hparams.basic_params1()', "hparams.add_hparam('num_channels',", '[64,', '128,', '256,', '416])', "hparams.add_hparam('num_layers_per_block',", '[1,', '1,', '10,', '1])', "hparams.add_hparam('bottleneck',", 'True)', "hparams.add_hparam('first_batch_norm',", '[False,', 'T... | 965,665 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | revnet_cifar_base | revnet_cifar_base | Tiny hparams suitable for CIFAR/etc. | [
"Tiny",
"hparams",
"suitable",
"for",
"CIFAR/etc."
] | def revnet_cifar_base():
hparams = revnet_base()
hparams.num_channels_init_block = 32
hparams.first_batch_norm = [False, True, True]
hparams.init_stride = 1
hparams.init_kernel_size = 3
hparams.init_maxpool = False
hparams.strides = [1, 2, 2]
hparams.batch_size = 128
hparams.weight_d... | ['def', 'revnet_cifar_base():', 'hparams', '=', 'revnet_base()', 'hparams.num_channels_init_block', '=', '32', 'hparams.first_batch_norm', '=', '[False,', 'True,', 'True]', 'hparams.init_stride', '=', '1', 'hparams.init_kernel_size', '=', '3', 'hparams.init_maxpool', '=', 'False', 'hparams.strides', '=', '[1,', '2,', '... | 965,666 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | revnet.py | revnet_range | revnet_range | Hyperparameters for tuning revnet. | [
"Hyperparameters",
"for",
"tuning",
"revnet."
] | def revnet_range(rhp):
rhp.set_float('learning_rate', 0.05, 0.2, scale=rhp.LOG_SCALE)
rhp.set_float('weight_decay', 1e-05, 0.001, scale=rhp.LOG_SCALE)
rhp.set_discrete('num_channels_init_block', [64, 128])
return rhp | ['def', 'revnet_range(rhp):', "rhp.set_float('learning_rate',", '0.05,', '0.2,', 'scale=rhp.LOG_SCALE)', "rhp.set_float('weight_decay',", '1e-05,', '0.001,', 'scale=rhp.LOG_SCALE)', "rhp.set_discrete('num_channels_init_block',", '[64,', '128])', 'return', 'rhp'] | 965,669 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | shake_shake.py | shake_shake_skip_connection | shake_shake_skip_connection | Adds a residual connection to the filter x for the shake-shake model. | [
"Adds",
"a",
"residual",
"connection",
"to",
"the",
"filter",
"x",
"for",
"the",
"shake-shake",
"model."
] | def shake_shake_skip_connection(x, output_filters, stride, is_training):
curr_filters = common_layers.shape_list(x)[-1]
if curr_filters == output_filters:
return x
stride_spec = [1, stride, stride, 1]
path1 = tf.nn.avg_pool(x, [1, 1, 1, 1], stride_spec, 'VALID')
path1 = tf.layers.conv2d(path... | ['def', 'shake_shake_skip_connection(x,', 'output_filters,', 'stride,', 'is_training):', 'curr_filters', '=', 'common_layers.shape_list(x)[-1]', 'if', 'curr_filters', '==', 'output_filters:', 'return', 'x', 'stride_spec', '=', '[1,', 'stride,', 'stride,', '1]', 'path1', '=', 'tf.nn.avg_pool(x,', '[1,', '1,', '1,', '1],... | 965,670 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | shake_shake.py | shake_shake_block | shake_shake_block | Builds a full shake-shake sub layer. | [
"Builds",
"a",
"full",
"shake-shake",
"sub",
"layer."
] | def shake_shake_block(x, output_filters, stride, hparams):
is_training = hparams.mode == tf.contrib.learn.ModeKeys.TRAIN
batch_size = common_layers.shape_list(x)[0]
rand_forward = [tf.random_uniform([batch_size, 1, 1, 1], minval=0, maxval=1, dtype=tf.float32) for _ in range(hparams.shake_shake_num_branches)... | ['def', 'shake_shake_block(x,', 'output_filters,', 'stride,', 'hparams):', 'is_training', '=', 'hparams.mode', '==', 'tf.contrib.learn.ModeKeys.TRAIN', 'batch_size', '=', 'common_layers.shape_list(x)[0]', 'rand_forward', '=', '[tf.random_uniform([batch_size,', '1,', '1,', '1],', 'minval=0,', 'maxval=1,', 'dtype=tf.floa... | 965,672 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | shake_shake.py | shake_shake_layer | shake_shake_layer | Builds many sub layers into one full layer. | [
"Builds",
"many",
"sub",
"layers",
"into",
"one",
"full",
"layer."
] | def shake_shake_layer(x, output_filters, num_blocks, stride, hparams):
for block_num in range(num_blocks):
curr_stride = stride if block_num == 0 else 1
with tf.variable_scope('layer_{}'.format(block_num)):
x = shake_shake_block(x, output_filters, curr_stride, hparams)
return x | ['def', 'shake_shake_layer(x,', 'output_filters,', 'num_blocks,', 'stride,', 'hparams):', 'for', 'block_num', 'in', 'range(num_blocks):', 'curr_stride', '=', 'stride', 'if', 'block_num', '==', '0', 'else', '1', 'with', "tf.variable_scope('layer_{}'.format(block_num)):", 'x', '=', 'shake_shake_block(x,', 'output_filters... | 965,673 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_base_vq_ada_32ex_packed | transformer_base_vq_ada_32ex_packed | Set of hyperparameters for lm1b packed following tpu params. | [
"Set",
"of",
"hyperparameters",
"for",
"lm1b",
"packed",
"following",
"tpu",
"params."
] | def transformer_base_vq_ada_32ex_packed():
hparams = transformer_base_v2()
expert_utils.update_hparams_for_vq_gating(hparams)
hparams.moe_num_experts = 32
hparams.gating_type = 'vq'
hparams.batch_size = 5072
hparams.ffn_layer = 'local_moe'
hparams.shared_embedding_and_softmax_weights = False... | ['def', 'transformer_base_vq_ada_32ex_packed():', 'hparams', '=', 'transformer_base_v2()', 'expert_utils.update_hparams_for_vq_gating(hparams)', 'hparams.moe_num_experts', '=', '32', 'hparams.gating_type', '=', "'vq'", 'hparams.batch_size', '=', '5072', 'hparams.ffn_layer', '=', "'local_moe'", 'hparams.shared_embedding... | 965,692 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_big_single_gpu | transformer_big_single_gpu | HParams for transformer big model for single GPU. | [
"HParams",
"for",
"transformer",
"big",
"model",
"for",
"single",
"GPU."
] | def transformer_big_single_gpu():
hparams = transformer_big()
hparams.layer_prepostprocess_dropout = 0.1
hparams.learning_rate_warmup_steps = 16000
return hparams | ['def', 'transformer_big_single_gpu():', 'hparams', '=', 'transformer_big()', 'hparams.layer_prepostprocess_dropout', '=', '0.1', 'hparams.learning_rate_warmup_steps', '=', '16000', 'return', 'hparams'] | 965,695 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_base_single_gpu | transformer_base_single_gpu | HParams for transformer base model for single GPU. | [
"HParams",
"for",
"transformer",
"base",
"model",
"for",
"single",
"GPU."
] | def transformer_base_single_gpu():
hparams = transformer_base()
hparams.batch_size = 2048
hparams.learning_rate_warmup_steps = 16000
return hparams | ['def', 'transformer_base_single_gpu():', 'hparams', '=', 'transformer_base()', 'hparams.batch_size', '=', '2048', 'hparams.learning_rate_warmup_steps', '=', '16000', 'return', 'hparams'] | 965,696 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_parsing_base | transformer_parsing_base | HParams for parsing on WSJ only. | [
"HParams",
"for",
"parsing",
"on",
"WSJ",
"only."
] | def transformer_parsing_base():
hparams = transformer_base()
hparams.attention_dropout = 0.2
hparams.layer_prepostprocess_dropout = 0.2
hparams.max_length = 512
hparams.learning_rate_warmup_steps = 16000
hparams.hidden_size = 1024
hparams.learning_rate = 0.05
hparams.shared_embedding_and... | ['def', 'transformer_parsing_base():', 'hparams', '=', 'transformer_base()', 'hparams.attention_dropout', '=', '0.2', 'hparams.layer_prepostprocess_dropout', '=', '0.2', 'hparams.max_length', '=', '512', 'hparams.learning_rate_warmup_steps', '=', '16000', 'hparams.hidden_size', '=', '1024', 'hparams.learning_rate', '='... | 965,700 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_parsing_ice | transformer_parsing_ice | HParams for parsing and tagging Icelandic text. | [
"HParams",
"for",
"parsing",
"and",
"tagging",
"Icelandic",
"text."
] | def transformer_parsing_ice():
hparams = transformer_base_single_gpu()
hparams.batch_size = 4096
hparams.shared_embedding_and_softmax_weights = False
return hparams | ['def', 'transformer_parsing_ice():', 'hparams', '=', 'transformer_base_single_gpu()', 'hparams.batch_size', '=', '4096', 'hparams.shared_embedding_and_softmax_weights', '=', 'False', 'return', 'hparams'] | 965,702 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_timeseries_tpu | transformer_timeseries_tpu | HParams for running Transformer model on timeseries on TPU. | [
"HParams",
"for",
"running",
"Transformer",
"model",
"on",
"timeseries",
"on",
"TPU."
] | def transformer_timeseries_tpu():
hparams = transformer_timeseries()
update_hparams_for_tpu(hparams)
hparams.batch_size = 256
return hparams | ['def', 'transformer_timeseries_tpu():', 'hparams', '=', 'transformer_timeseries()', 'update_hparams_for_tpu(hparams)', 'hparams.batch_size', '=', '256', 'return', 'hparams'] | 965,707 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_tpu_bf16_activation | transformer_tpu_bf16_activation | HParams for Transformer model with BF16 activation on TPU. | [
"HParams",
"for",
"Transformer",
"model",
"with",
"BF16",
"activation",
"on",
"TPU."
] | def transformer_tpu_bf16_activation():
hparams = transformer_tpu()
hparams.activation_dtype = 'bfloat16'
return hparams | ['def', 'transformer_tpu_bf16_activation():', 'hparams', '=', 'transformer_tpu()', 'hparams.activation_dtype', '=', "'bfloat16'", 'return', 'hparams'] | 965,708 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_packed_tpu | transformer_packed_tpu | Deprecated alias for transformer_tpu(). | [
"Deprecated",
"alias",
"for",
"transformer_tpu()."
] | def transformer_packed_tpu():
return transformer_tpu() | ['def', 'transformer_packed_tpu():', 'return', 'transformer_tpu()'] | 965,709 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_librispeech_v1 | transformer_librispeech_v1 | HParams for training ASR model on LibriSpeech V1. | [
"HParams",
"for",
"training",
"ASR",
"model",
"on",
"LibriSpeech",
"V1."
] | def transformer_librispeech_v1():
hparams = transformer_base()
hparams.num_heads = 4
hparams.filter_size = 1024
hparams.hidden_size = 256
hparams.num_encoder_layers = 5
hparams.num_decoder_layers = 3
hparams.learning_rate = 0.15
hparams.batch_size = 6000000
librispeech.set_librispeec... | ['def', 'transformer_librispeech_v1():', 'hparams', '=', 'transformer_base()', 'hparams.num_heads', '=', '4', 'hparams.filter_size', '=', '1024', 'hparams.hidden_size', '=', '256', 'hparams.num_encoder_layers', '=', '5', 'hparams.num_decoder_layers', '=', '3', 'hparams.learning_rate', '=', '0.15', 'hparams.batch_size',... | 965,717 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_librispeech_tpu_v2 | transformer_librispeech_tpu_v2 | HParams for training ASR model on Librispeech on TPU v2. | [
"HParams",
"for",
"training",
"ASR",
"model",
"on",
"Librispeech",
"on",
"TPU",
"v2."
] | def transformer_librispeech_tpu_v2():
hparams = transformer_librispeech_v2()
update_hparams_for_tpu(hparams)
hparams.batch_size = 16
librispeech.set_librispeech_length_hparams(hparams)
return hparams | ['def', 'transformer_librispeech_tpu_v2():', 'hparams', '=', 'transformer_librispeech_v2()', 'update_hparams_for_tpu(hparams)', 'hparams.batch_size', '=', '16', 'librispeech.set_librispeech_length_hparams(hparams)', 'return', 'hparams'] | 965,720 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_librispeech_tpu | transformer_librispeech_tpu | HParams for training ASR model on Librispeech on TPU. | [
"HParams",
"for",
"training",
"ASR",
"model",
"on",
"Librispeech",
"on",
"TPU."
] | def transformer_librispeech_tpu():
return transformer_librispeech_tpu_v2() | ['def', 'transformer_librispeech_tpu():', 'return', 'transformer_librispeech_tpu_v2()'] | 965,722 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_common_voice | transformer_common_voice | HParams for training ASR model on Mozilla Common Voice. | [
"HParams",
"for",
"training",
"ASR",
"model",
"on",
"Mozilla",
"Common",
"Voice."
] | def transformer_common_voice():
return transformer_librispeech() | ['def', 'transformer_common_voice():', 'return', 'transformer_librispeech()'] | 965,723 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_common_voice_tpu | transformer_common_voice_tpu | HParams for training ASR model on Mozilla Common Voice on TPU. | [
"HParams",
"for",
"training",
"ASR",
"model",
"on",
"Mozilla",
"Common",
"Voice",
"on",
"TPU."
] | def transformer_common_voice_tpu():
hparams = transformer_librispeech_tpu()
hparams.batch_size = 8
return hparams | ['def', 'transformer_common_voice_tpu():', 'hparams', '=', 'transformer_librispeech_tpu()', 'hparams.batch_size', '=', '8', 'return', 'hparams'] | 965,724 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer.py | transformer_supervised_attention | transformer_supervised_attention | HParams for supervised attention problems. | [
"HParams",
"for",
"supervised",
"attention",
"problems."
] | def transformer_supervised_attention():
hparams = transformer_base()
hparams.add_hparam('expected_attention_loss_type', 'kl_divergence')
hparams.add_hparam('expected_attention_loss_multiplier', 1.0)
return hparams | ['def', 'transformer_supervised_attention():', 'hparams', '=', 'transformer_base()', "hparams.add_hparam('expected_attention_loss_type',", "'kl_divergence')", "hparams.add_hparam('expected_attention_loss_multiplier',", '1.0)', 'return', 'hparams'] | 965,725 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vanilla_gan.py | AbstractGAN.generator | generator | Generator outputting image in [0, 1]. | [
"Generator",
"outputting",
"image",
"in",
"[0,",
"1]."
] | def generator(self, z, is_training, out_shape):
hparams = self.hparams
(height, width, c_dim) = out_shape
batch_size = hparams.batch_size
with tf.variable_scope('generator', initializer=tf.random_normal_initializer(stddev=0.02)):
net = tf.layers.dense(z, 1024, name='g_fc1')
net = tf.laye... | ['def', 'generator(self,', 'z,', 'is_training,', 'out_shape):', 'hparams', '=', 'self.hparams', '(height,', 'width,', 'c_dim)', '=', 'out_shape', 'batch_size', '=', 'hparams.batch_size', 'with', "tf.variable_scope('generator',", 'initializer=tf.random_normal_initializer(stddev=0.02)):', 'net', '=', 'tf.layers.dense(z,'... | 965,731 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vanilla_gan.py | AbstractGAN.top | top | Override the top function to not do anything. | [
"Override",
"the",
"top",
"function",
"to",
"not",
"do",
"anything."
] | def top(self, body_output, features):
return body_output | ['def', 'top(self,', 'body_output,', 'features):', 'return', 'body_output'] | 965,734 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | adafactor_experiments.py | afx_adam | afx_adam | Old version - Adam. | [
"Old",
"version",
"-",
"Adam."
] | def afx_adam():
hparams = transformer.transformer_base_v2()
hparams.optimizer_adam_beta1 = 0.9
hparams.optimizer_adam_beta2 = 0.999
hparams.symbol_modality_num_shards = 1
hparams.batch_size = 2048
hparams.optimizer = 'Adam'
hparams.learning_rate_schedule = 'constant*rsqrt_decay*linear_warmup... | ['def', 'afx_adam():', 'hparams', '=', 'transformer.transformer_base_v2()', 'hparams.optimizer_adam_beta1', '=', '0.9', 'hparams.optimizer_adam_beta2', '=', '0.999', 'hparams.symbol_modality_num_shards', '=', '1', 'hparams.batch_size', '=', '2048', 'hparams.optimizer', '=', "'Adam'", 'hparams.learning_rate_schedule', '... | 965,738 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | adafactor_experiments.py | afx_small | afx_small | Small transformer model with small batch size for fast step times. | [
"Small",
"transformer",
"model",
"with",
"small",
"batch",
"size",
"for",
"fast",
"step",
"times."
] | def afx_small():
hparams = transformer.transformer_tpu()
hparams.filter_size = 1024
hparams.num_heads = 4
hparams.num_hidden_layers = 3
hparams.batch_size = 512
return hparams | ['def', 'afx_small():', 'hparams', '=', 'transformer.transformer_tpu()', 'hparams.filter_size', '=', '1024', 'hparams.num_heads', '=', '4', 'hparams.num_hidden_layers', '=', '3', 'hparams.batch_size', '=', '512', 'return', 'hparams'] | 965,742 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_residual_discrete | autoencoder_residual_discrete | Residual discrete autoencoder model. | [
"Residual",
"discrete",
"autoencoder",
"model."
] | def autoencoder_residual_discrete():
hparams = autoencoder_residual()
hparams.bottleneck_bits = 1024
hparams.bottleneck_noise = 0.05
hparams.add_hparam('discretize_warmup_steps', 16000)
hparams.add_hparam('bottleneck_kind', 'tanh_discrete')
hparams.add_hparam('isemhash_noise_dev', 0.5)
hpara... | ['def', 'autoencoder_residual_discrete():', 'hparams', '=', 'autoencoder_residual()', 'hparams.bottleneck_bits', '=', '1024', 'hparams.bottleneck_noise', '=', '0.05', "hparams.add_hparam('discretize_warmup_steps',", '16000)', "hparams.add_hparam('bottleneck_kind',", "'tanh_discrete')", "hparams.add_hparam('isemhash_noi... | 965,788 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_ordered_discrete | autoencoder_ordered_discrete | Ordered discrete autoencoder model. | [
"Ordered",
"discrete",
"autoencoder",
"model."
] | def autoencoder_ordered_discrete():
hparams = autoencoder_residual_discrete()
hparams.bottleneck_noise = 0.05
hparams.gan_loss_factor = 0.05
hparams.add_hparam('unordered', True)
return hparams | ['def', 'autoencoder_ordered_discrete():', 'hparams', '=', 'autoencoder_residual_discrete()', 'hparams.bottleneck_noise', '=', '0.05', 'hparams.gan_loss_factor', '=', '0.05', "hparams.add_hparam('unordered',", 'True)', 'return', 'hparams'] | 965,790 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_ordered_text | autoencoder_ordered_text | Ordered discrete autoencoder model for text. | [
"Ordered",
"discrete",
"autoencoder",
"model",
"for",
"text."
] | def autoencoder_ordered_text():
hparams = autoencoder_ordered_discrete()
hparams.bottleneck_bits = 512
hparams.num_hidden_layers = 7
hparams.batch_size = 1024
hparams.autoregressive_mode = 'conv5'
hparams.max_hidden_size = 1024
hparams.target_modality = 'symbol:identity'
hparams.input_mo... | ['def', 'autoencoder_ordered_text():', 'hparams', '=', 'autoencoder_ordered_discrete()', 'hparams.bottleneck_bits', '=', '512', 'hparams.num_hidden_layers', '=', '7', 'hparams.batch_size', '=', '1024', 'hparams.autoregressive_mode', '=', "'conv5'", 'hparams.max_hidden_size', '=', '1024', 'hparams.target_modality', '=',... | 965,794 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_ordered_text_small | autoencoder_ordered_text_small | Ordered discrete autoencoder model for text, small version. | [
"Ordered",
"discrete",
"autoencoder",
"model",
"for",
"text,",
"small",
"version."
] | def autoencoder_ordered_text_small():
hparams = autoencoder_ordered_text()
hparams.bottleneck_bits = 14
hparams.num_hidden_layers = 2
hparams.hidden_size = 64
hparams.max_hidden_size = 512
hparams.bottleneck_noise = 0.0
hparams.autoregressive_mode = 'conv5'
hparams.sample_height = 4
... | ['def', 'autoencoder_ordered_text_small():', 'hparams', '=', 'autoencoder_ordered_text()', 'hparams.bottleneck_bits', '=', '14', 'hparams.num_hidden_layers', '=', '2', 'hparams.hidden_size', '=', '64', 'hparams.max_hidden_size', '=', '512', 'hparams.bottleneck_noise', '=', '0.0', 'hparams.autoregressive_mode', '=', "'c... | 965,795 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_ordered_discrete_vq | autoencoder_ordered_discrete_vq | Ordered discrete autoencoder model with VQ bottleneck. | [
"Ordered",
"discrete",
"autoencoder",
"model",
"with",
"VQ",
"bottleneck."
] | def autoencoder_ordered_discrete_vq():
hparams = autoencoder_ordered_discrete()
hparams.bottleneck_kind = 'vq'
hparams.bottleneck_bits = 16
return hparams | ['def', 'autoencoder_ordered_discrete_vq():', 'hparams', '=', 'autoencoder_ordered_discrete()', 'hparams.bottleneck_kind', '=', "'vq'", 'hparams.bottleneck_bits', '=', '16', 'return', 'hparams'] | 965,796 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_discrete_pong | autoencoder_discrete_pong | Discrete autoencoder model for compressing pong frames. | [
"Discrete",
"autoencoder",
"model",
"for",
"compressing",
"pong",
"frames."
] | def autoencoder_discrete_pong():
hparams = autoencoder_ordered_discrete()
hparams.num_hidden_layers = 2
hparams.bottleneck_bits = 24
hparams.batch_size = 2
hparams.bottleneck_noise = 0.2
hparams.max_hidden_size = 1024
return hparams | ['def', 'autoencoder_discrete_pong():', 'hparams', '=', 'autoencoder_ordered_discrete()', 'hparams.num_hidden_layers', '=', '2', 'hparams.bottleneck_bits', '=', '24', 'hparams.batch_size', '=', '2', 'hparams.bottleneck_noise', '=', '0.2', 'hparams.max_hidden_size', '=', '1024', 'return', 'hparams'] | 965,797 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | autoencoder_range | autoencoder_range | Tuning grid of the main autoencoder params. | [
"Tuning",
"grid",
"of",
"the",
"main",
"autoencoder",
"params."
] | def autoencoder_range(rhp):
rhp.set_float('dropout', 0.01, 0.3)
rhp.set_float('gan_loss_factor', 0.01, 0.1)
rhp.set_float('bottleneck_l2_factor', 0.001, 0.1, scale=rhp.LOG_SCALE)
rhp.set_discrete('bottleneck_warmup_steps', [200, 2000])
rhp.set_float('gumbel_temperature', 0, 1)
rhp.set_float('gum... | ['def', 'autoencoder_range(rhp):', "rhp.set_float('dropout',", '0.01,', '0.3)', "rhp.set_float('gan_loss_factor',", '0.01,', '0.1)', "rhp.set_float('bottleneck_l2_factor',", '0.001,', '0.1,', 'scale=rhp.LOG_SCALE)', "rhp.set_discrete('bottleneck_warmup_steps',", '[200,', '2000])', "rhp.set_float('gumbel_temperature',",... | 965,799 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | AutoencoderBasic.image_summary | image_summary | Helper for image summaries that are safe on TPU. | [
"Helper",
"for",
"image",
"summaries",
"that",
"are",
"safe",
"on",
"TPU."
] | def image_summary(self, name, image_logits, max_outputs=1):
if len(image_logits.get_shape()) != 5:
tf.logging.info('Not generating image summary, maybe not an image.')
return
return tf.summary.image(name, common_layers.tpu_safe_image_summary(tf.argmax(image_logits, -1)), max_outputs=max_outputs) | ['def', 'image_summary(self,', 'name,', 'image_logits,', 'max_outputs=1):', 'if', 'len(image_logits.get_shape())', '!=', '5:', "tf.logging.info('Not", 'generating', 'image', 'summary,', 'maybe', 'not', 'an', "image.')", 'return', 'return', 'tf.summary.image(name,', 'common_layers.tpu_safe_image_summary(tf.argmax(image_... | 965,800 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | AutoencoderBasic.embed | embed | Input embedding with a non-zero bias for uniform inputs. | [
"Input",
"embedding",
"with",
"a",
"non-zero",
"bias",
"for",
"uniform",
"inputs."
] | def embed(self, x):
with tf.variable_scope('embed', reuse=tf.AUTO_REUSE):
x_shape = common_layers.shape_list(x)
x = tf.reshape(x, x_shape[:-2] + [x_shape[-2] * x_shape[-1]])
x = tf.layers.dense(x, self.hparams.hidden_size, name='embed', activation=common_layers.belu, bias_initializer=tf.rand... | ['def', 'embed(self,', 'x):', 'with', "tf.variable_scope('embed',", 'reuse=tf.AUTO_REUSE):', 'x_shape', '=', 'common_layers.shape_list(x)', 'x', '=', 'tf.reshape(x,', 'x_shape[:-2]', '+', '[x_shape[-2]', '*', 'x_shape[-1]])', 'x', '=', 'tf.layers.dense(x,', 'self.hparams.hidden_size,', "name='embed',", 'activation=comm... | 965,801 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | autoencoders.py | AutoencoderBasic.decode | decode | Auto-decode from the bottleneck and return the result. | [
"Auto-decode",
"from",
"the",
"bottleneck",
"and",
"return",
"the",
"result."
] | def decode(self, bottleneck):
shape = common_layers.shape_list(bottleneck)
try:
num_channels = self.hparams.problem.num_channels
except AttributeError:
num_channels = 1
dummy_targets = tf.zeros(shape[:-1] + [num_channels])
if len(shape) > 4:
bottleneck = tf.squeeze(bottleneck... | ['def', 'decode(self,', 'bottleneck):', 'shape', '=', 'common_layers.shape_list(bottleneck)', 'try:', 'num_channels', '=', 'self.hparams.problem.num_channels', 'except', 'AttributeError:', 'num_channels', '=', '1', 'dummy_targets', '=', 'tf.zeros(shape[:-1]', '+', '[num_channels])', 'if', 'len(shape)', '>', '4:', 'bott... | 965,804 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | gene_expression.py | conv_layer | conv_layer | Single conv layer with relu, optional pooling, and dropout. | [
"Single",
"conv",
"layer",
"with",
"relu,",
"optional",
"pooling,",
"and",
"dropout."
] | def conv_layer(x, hidden_size, kernel_size, stride, pooling_window, dropout_rate, dilation_rate, name='conv'):
with tf.variable_scope(name):
out = x
out = common_layers.conv1d_block(out, hidden_size, [(dilation_rate, kernel_size)], strides=stride, first_relu=False, padding='same')
out = tf.n... | ['def', 'conv_layer(x,', 'hidden_size,', 'kernel_size,', 'stride,', 'pooling_window,', 'dropout_rate,', 'dilation_rate,', "name='conv'):", 'with', 'tf.variable_scope(name):', 'out', '=', 'x', 'out', '=', 'common_layers.conv1d_block(out,', 'hidden_size,', '[(dilation_rate,', 'kernel_size)],', 'strides=stride,', 'first_r... | 965,807 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow.py | Glow.top_prior | top_prior | Objective based on the prior over latent z. | [
"Objective",
"based",
"on",
"the",
"prior",
"over",
"latent",
"z."
] | def top_prior(self, z):
return glow_ops.top_prior('top_prior', z, learn_prior=self.hparams.top_prior) | ['def', 'top_prior(self,', 'z):', 'return', "glow_ops.top_prior('top_prior',", 'z,', 'learn_prior=self.hparams.top_prior)'] | 965,810 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops.py | set_eps | set_eps | Z = eps * sigma + mu. | [
"Z",
"=",
"eps",
"*",
"sigma",
"+",
"mu."
] | def set_eps(dist, eps):
return eps * dist.scale + dist.loc | ['def', 'set_eps(dist,', 'eps):', 'return', 'eps', '*', 'dist.scale', '+', 'dist.loc'] | 965,812 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops.py | get_variable_ddi | get_variable_ddi | Wrapper for data-dependent initialization. | [
"Wrapper",
"for",
"data-dependent",
"initialization."
] | def get_variable_ddi(name, shape, initial_value, dtype=tf.float32, init=False, trainable=True):
if isinstance(init, bool):
init = tf.constant(init, dtype=tf.bool)
w = tf.get_variable(name, shape, dtype, None, trainable=trainable)
return tf.cond(init, lambda : assign(w, initial_value), lambda : w) | ['def', 'get_variable_ddi(name,', 'shape,', 'initial_value,', 'dtype=tf.float32,', 'init=False,', 'trainable=True):', 'if', 'isinstance(init,', 'bool):', 'init', '=', 'tf.constant(init,', 'dtype=tf.bool)', 'w', '=', 'tf.get_variable(name,', 'shape,', 'dtype,', 'None,', 'trainable=trainable)', 'return', 'tf.cond(init,',... | 965,813 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops.py | actnorm_scale | actnorm_scale | Per-channel scaling of x. | [
"Per-channel",
"scaling",
"of",
"x."
] | def actnorm_scale(name, x, logscale_factor=3.0, reverse=False, init=False):
x_shape = common_layers.shape_list(x)
with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
assert len(x_shape) == 2 or len(x_shape) == 4
if len(x_shape) == 2:
x_var = tf.reduce_mean(x ** 2, [0], keepdims=True)
... | ['def', 'actnorm_scale(name,', 'x,', 'logscale_factor=3.0,', 'reverse=False,', 'init=False):', 'x_shape', '=', 'common_layers.shape_list(x)', 'with', 'tf.variable_scope(name,', 'reuse=tf.AUTO_REUSE):', 'assert', 'len(x_shape)', '==', '2', 'or', 'len(x_shape)', '==', '4', 'if', 'len(x_shape)', '==', '2:', 'x_var', '=', ... | 965,816 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops.py | affine_coupling | affine_coupling | Reversible affine coupling layer. | [
"Reversible",
"affine",
"coupling",
"layer."
] | def affine_coupling(name, x, mid_channels=512, reverse=False):
with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
x_shape = common_layers.shape_list(x)
(x1, x2) = tf.split(x, num_or_size_splits=2, axis=-1)
z1 = x1
log_scale_and_shift = nn('nn', x1, mid_channels, x_shape[-1])
... | ['def', 'affine_coupling(name,', 'x,', 'mid_channels=512,', 'reverse=False):', 'with', 'tf.variable_scope(name,', 'reuse=tf.AUTO_REUSE):', 'x_shape', '=', 'common_layers.shape_list(x)', '(x1,', 'x2)', '=', 'tf.split(x,', 'num_or_size_splits=2,', 'axis=-1)', 'z1', '=', 'x1', 'log_scale_and_shift', '=', "nn('nn',", 'x1,'... | 965,820 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops.py | top_prior | top_prior | Log probability of x being gaussian. | [
"Log",
"probability",
"of",
"x",
"being",
"gaussian."
] | def top_prior(name, x, learn_prior='normal'):
with tf.variable_scope(name, reuse=tf.AUTO_REUSE):
h = tf.zeros_like(x)
if learn_prior == 'normal':
prior_dist = tf.distributions.Normal(h, tf.exp(h))
elif learn_prior == 'single_conv':
prior_dist = split_prior('top_learn_... | ['def', 'top_prior(name,', 'x,', "learn_prior='normal'):", 'with', 'tf.variable_scope(name,', 'reuse=tf.AUTO_REUSE):', 'h', '=', 'tf.zeros_like(x)', 'if', 'learn_prior', '==', "'normal':", 'prior_dist', '=', 'tf.distributions.Normal(h,', 'tf.exp(h))', 'elif', 'learn_prior', '==', "'single_conv':", 'prior_dist', '=', "s... | 965,826 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | glow_ops_test.py | GlowOpsTest.test_actnorm | test_actnorm | Test that actnorm provides activations with zero channel-mean. | [
"Test",
"that",
"actnorm",
"provides",
"activations",
"with",
"zero",
"channel-mean."
] | def test_actnorm(self):
with tf.Graph().as_default():
x_t = tf.random_normal((16, 32, 32, 3), mean=50.0, stddev=2.0)
x_act = glow_ops.actnorm('actnorm', x_t, init=True)
with tf.Session() as session:
(x_act_np, _) = session.run(x_act)
channel_mean = np.mean(x_act_np, a... | ['def', 'test_actnorm(self):', 'with', 'tf.Graph().as_default():', 'x_t', '=', 'tf.random_normal((16,', '32,', '32,', '3),', 'mean=50.0,', 'stddev=2.0)', 'x_act', '=', "glow_ops.actnorm('actnorm',", 'x_t,', 'init=True)', 'with', 'tf.Session()', 'as', 'session:', '(x_act_np,', '_)', '=', 'session.run(x_act)', 'channel_m... | 965,828 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | lm_experiments.py | lmx_relative | lmx_relative | Language model using relative attention. | [
"Language",
"model",
"using",
"relative",
"attention."
] | def lmx_relative():
hparams = lmx_base()
hparams.self_attention_type = 'dot_product_relative_v2'
hparams.activation_dtype = 'float32'
hparams.weight_dtype = 'float32'
return hparams | ['def', 'lmx_relative():', 'hparams', '=', 'lmx_base()', 'hparams.self_attention_type', '=', "'dot_product_relative_v2'", 'hparams.activation_dtype', '=', "'float32'", 'hparams.weight_dtype', '=', "'float32'", 'return', 'hparams'] | 965,835 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | lm_experiments.py | lmx_relative_nopos | lmx_relative_nopos | Language model using relative attention and no positional encoding. | [
"Language",
"model",
"using",
"relative",
"attention",
"and",
"no",
"positional",
"encoding."
] | def lmx_relative_nopos():
hparams = lmx_relative()
hparams.pos = 'none'
return hparams | ['def', 'lmx_relative_nopos():', 'hparams', '=', 'lmx_relative()', 'hparams.pos', '=', "'none'", 'return', 'hparams'] | 965,836 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | rl.py | feed_forward_cnn_small_categorical_fun | feed_forward_cnn_small_categorical_fun | Small cnn network with categorical output. | [
"Small",
"cnn",
"network",
"with",
"categorical",
"output."
] | def feed_forward_cnn_small_categorical_fun(action_space, config, observations):
obs_shape = common_layers.shape_list(observations)
x = tf.reshape(observations, [-1] + obs_shape[2:])
with tf.variable_scope('network_parameters'):
with tf.variable_scope('feed_forward_cnn_small'):
x = tf.to_... | ['def', 'feed_forward_cnn_small_categorical_fun(action_space,', 'config,', 'observations):', 'obs_shape', '=', 'common_layers.shape_list(observations)', 'x', '=', 'tf.reshape(observations,', '[-1]', '+', 'obs_shape[2:])', 'with', "tf.variable_scope('network_parameters'):", 'with', "tf.variable_scope('feed_forward_cnn_s... | 965,847 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | rl.py | dense_bitwise_categorical_fun | dense_bitwise_categorical_fun | Dense network with bitwise input and categorical output. | [
"Dense",
"network",
"with",
"bitwise",
"input",
"and",
"categorical",
"output."
] | def dense_bitwise_categorical_fun(action_space, config, observations):
del config
obs_shape = common_layers.shape_list(observations)
x = tf.reshape(observations, [-1] + obs_shape[2:])
with tf.variable_scope('network_parameters'):
with tf.variable_scope('dense_bitwise'):
x = discretiz... | ['def', 'dense_bitwise_categorical_fun(action_space,', 'config,', 'observations):', 'del', 'config', 'obs_shape', '=', 'common_layers.shape_list(observations)', 'x', '=', 'tf.reshape(observations,', '[-1]', '+', 'obs_shape[2:])', 'with', "tf.variable_scope('network_parameters'):", 'with', "tf.variable_scope('dense_bitw... | 965,848 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | rl.py | random_policy_fun | random_policy_fun | Random policy with categorical output. | [
"Random",
"policy",
"with",
"categorical",
"output."
] | def random_policy_fun(action_space, unused_config, observations):
obs_shape = observations.shape.as_list()
with tf.variable_scope('network_parameters'):
value = tf.zeros(obs_shape[:2])
policy = tf.distributions.Categorical(probs=[[[1.0 / float(action_space.n)] * action_space.n] * (obs_shape[0] *... | ['def', 'random_policy_fun(action_space,', 'unused_config,', 'observations):', 'obs_shape', '=', 'observations.shape.as_list()', 'with', "tf.variable_scope('network_parameters'):", 'value', '=', 'tf.zeros(obs_shape[:2])', 'policy', '=', 'tf.distributions.Categorical(probs=[[[1.0', '/', 'float(action_space.n)]', '*', 'a... | 965,849 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | super_lm.py | super_lm_moe_h4 | super_lm_moe_h4 | Add mixture of experts. | [
"Add",
"mixture",
"of",
"experts."
] | def super_lm_moe_h4():
hparams = super_lm_moe()
hparams.layers = 'n,multihead-att,m,d,a,n,moe,m,d,a,' * 4 + 'n,ffn,d'
return hparams | ['def', 'super_lm_moe_h4():', 'hparams', '=', 'super_lm_moe()', 'hparams.layers', '=', "'n,multihead-att,m,d,a,n,moe,m,d,a,'", '*', '4', '+', "'n,ffn,d'", 'return', 'hparams'] | 965,851 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer_nat.py | ae_transformer_internal | ae_transformer_internal | Main step used for training. | [
"Main",
"step",
"used",
"for",
"training."
] | def ae_transformer_internal(inputs, targets, target_space, hparams, cache=None):
inputs = common_layers.flatten4d3d(inputs)
(inputs, ed) = encode(inputs, target_space, hparams, 'input_enc')
losses = {'extra': tf.constant(0.0), 'latent_pred': tf.constant(0.0)}
max_targets_len_from_inputs = tf.concat([inp... | ['def', 'ae_transformer_internal(inputs,', 'targets,', 'target_space,', 'hparams,', 'cache=None):', 'inputs', '=', 'common_layers.flatten4d3d(inputs)', '(inputs,', 'ed)', '=', 'encode(inputs,', 'target_space,', 'hparams,', "'input_enc')", 'losses', '=', "{'extra':", 'tf.constant(0.0),', "'latent_pred':", 'tf.constant(0... | 965,869 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | transformer_symshard.py | transformer_symshard_lm_0 | transformer_symshard_lm_0 | For language modeling - suggested problem languagemodel_lm1b8k_packed. | [
"For",
"language",
"modeling",
"-",
"suggested",
"problem",
"languagemodel_lm1b8k_packed."
] | def transformer_symshard_lm_0():
hparams = transformer_symshard_base()
hparams.label_smoothing = 0
return hparams | ['def', 'transformer_symshard_lm_0():', 'hparams', '=', 'transformer_symshard_base()', 'hparams.label_smoothing', '=', '0', 'return', 'hparams'] | 965,877 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer.py | UniversalTransformer.body | body | Universal Transformer main model_fn. | [
"Universal",
"Transformer",
"main",
"model_fn."
] | def body(self, features):
hparams = self._hparams
if hparams.add_position_timing_signal:
hparams.pos = None
if self.has_input:
inputs = features['inputs']
target_space = features['target_space_id']
(encoder_output, encoder_decoder_attention_bias, enc_extra_output) = self.enco... | ['def', 'body(self,', 'features):', 'hparams', '=', 'self._hparams', 'if', 'hparams.add_position_timing_signal:', 'hparams.pos', '=', 'None', 'if', 'self.has_input:', 'inputs', '=', "features['inputs']", 'target_space', '=', "features['target_space_id']", '(encoder_output,', 'encoder_decoder_attention_bias,', 'enc_extr... | 965,896 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | universal_transformer_layer | universal_transformer_layer | Core function applying the universal transformer layer. | [
"Core",
"function",
"applying",
"the",
"universal",
"transformer",
"layer."
] | def universal_transformer_layer(x, hparams, ffn_unit, attention_unit, pad_remover=None):
def add_vanilla_transformer_layer(x, num_layers):
if hparams.add_position_timing_signal:
x = common_attention.add_timing_signal_1d(x)
for layer in range(num_layers):
with tf.variable_sco... | ['def', 'universal_transformer_layer(x,', 'hparams,', 'ffn_unit,', 'attention_unit,', 'pad_remover=None):', 'def', 'add_vanilla_transformer_layer(x,', 'num_layers):', 'if', 'hparams.add_position_timing_signal:', 'x', '=', 'common_attention.add_timing_signal_1d(x)', 'for', 'layer', 'in', 'range(num_layers):', 'with', "t... | 965,900 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | transformer_encoder_attention_unit | transformer_encoder_attention_unit | Applies multihead attention function which is parametrised for encoding. | [
"Applies",
"multihead",
"attention",
"function",
"which",
"is",
"parametrised",
"for",
"encoding."
] | def transformer_encoder_attention_unit(x, hparams, encoder_self_attention_bias, attention_dropout_broadcast_dims, save_weights_to=None, make_image_summary=True):
with tf.variable_scope('self_attention'):
y = common_attention.multihead_attention(common_layers.layer_preprocess(x, hparams), None, encoder_self_... | ['def', 'transformer_encoder_attention_unit(x,', 'hparams,', 'encoder_self_attention_bias,', 'attention_dropout_broadcast_dims,', 'save_weights_to=None,', 'make_image_summary=True):', 'with', "tf.variable_scope('self_attention'):", 'y', '=', 'common_attention.multihead_attention(common_layers.layer_preprocess(x,', 'hpa... | 965,903 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | transformer_decoder_attention_unit | transformer_decoder_attention_unit | Applies multihead attention function which is parametrised for decoding. | [
"Applies",
"multihead",
"attention",
"function",
"which",
"is",
"parametrised",
"for",
"decoding."
] | def transformer_decoder_attention_unit(x, hparams, encoder_output, decoder_self_attention_bias, encoder_decoder_attention_bias, attention_dropout_broadcast_dims, save_weights_to=None, make_image_summary=True):
with tf.variable_scope('self_attention'):
y = common_attention.multihead_attention(common_layers.l... | ['def', 'transformer_decoder_attention_unit(x,', 'hparams,', 'encoder_output,', 'decoder_self_attention_bias,', 'encoder_decoder_attention_bias,', 'attention_dropout_broadcast_dims,', 'save_weights_to=None,', 'make_image_summary=True):', 'with', "tf.variable_scope('self_attention'):", 'y', '=', 'common_attention.multih... | 965,905 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | universal_transformer_act_basic | universal_transformer_act_basic | Basic universal_transformer with ACT based on remainder-distribution ACT. | [
"Basic",
"universal_transformer",
"with",
"ACT",
"based",
"on",
"remainder-distribution",
"ACT."
] | def universal_transformer_act_basic(x, hparams, ffn_unit, attention_unit):
state = x
act_max_steps = hparams.act_max_steps
threshold = 1.0 - hparams.act_epsilon
batch_size = tf.shape(state)[0]
length = tf.shape(state)[1]
halting_probability = tf.zeros((batch_size, length), name='halting_probabil... | ['def', 'universal_transformer_act_basic(x,', 'hparams,', 'ffn_unit,', 'attention_unit):', 'state', '=', 'x', 'act_max_steps', '=', 'hparams.act_max_steps', 'threshold', '=', '1.0', '-', 'hparams.act_epsilon', 'batch_size', '=', 'tf.shape(state)[0]', 'length', '=', 'tf.shape(state)[1]', 'halting_probability', '=', 'tf.... | 965,913 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | universal_transformer_act_random | universal_transformer_act_random | universal_transformer with ACT with random halting probability. | [
"universal_transformer",
"with",
"ACT",
"with",
"random",
"halting",
"probability."
] | def universal_transformer_act_random(x, hparams, ffn_unit, attention_unit):
state = x
act_max_steps = hparams.act_max_steps
threshold = 1.0 - hparams.act_epsilon
batch_size = tf.shape(state)[0]
length = tf.shape(state)[1]
halting_probability = tf.zeros((batch_size, length), name='halting_probabi... | ['def', 'universal_transformer_act_random(x,', 'hparams,', 'ffn_unit,', 'attention_unit):', 'state', '=', 'x', 'act_max_steps', '=', 'hparams.act_max_steps', 'threshold', '=', '1.0', '-', 'hparams.act_epsilon', 'batch_size', '=', 'tf.shape(state)[0]', 'length', '=', 'tf.shape(state)[1]', 'halting_probability', '=', 'tf... | 965,916 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | fill_memory_slot | fill_memory_slot | Fills the memory slot at a particular index with the given value. | [
"Fills",
"the",
"memory",
"slot",
"at",
"a",
"particular",
"index",
"with",
"the",
"given",
"value."
] | def fill_memory_slot(memory, value, index):
mask = tf.to_float(tf.one_hot(index, tf.shape(memory)[0])[:, None, None, None])
fill_memory = (1 - mask) * memory + mask * value[None, ...]
return fill_memory | ['def', 'fill_memory_slot(memory,', 'value,', 'index):', 'mask', '=', 'tf.to_float(tf.one_hot(index,', 'tf.shape(memory)[0])[:,', 'None,', 'None,', 'None])', 'fill_memory', '=', '(1', '-', 'mask)', '*', 'memory', '+', 'mask', '*', 'value[None,', '...]', 'return', 'fill_memory'] | 965,917 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | step_preprocess | step_preprocess | Preprocess the input at the beginning of each step. | [
"Preprocess",
"the",
"input",
"at",
"the",
"beginning",
"of",
"each",
"step."
] | def step_preprocess(x, step, hparams):
original_channel_size = common_layers.shape_list(x)[-1]
if hparams.add_position_timing_signal:
x = add_position_timing_signal(x, step, hparams)
if hparams.add_step_timing_signal:
x = add_step_timing_signal(x, step, hparams)
if (hparams.add_position_... | ['def', 'step_preprocess(x,', 'step,', 'hparams):', 'original_channel_size', '=', 'common_layers.shape_list(x)[-1]', 'if', 'hparams.add_position_timing_signal:', 'x', '=', 'add_position_timing_signal(x,', 'step,', 'hparams)', 'if', 'hparams.add_step_timing_signal:', 'x', '=', 'add_step_timing_signal(x,', 'step,', 'hpar... | 965,919 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | universal_transformer_util.py | add_position_timing_signal | add_position_timing_signal | Add n-dimensional embedding as the position (horizontal) timing signal. | [
"Add",
"n-dimensional",
"embedding",
"as",
"the",
"position",
"(horizontal)",
"timing",
"signal."
] | def add_position_timing_signal(x, step, hparams):
if not hparams.position_start_index:
index = 0
elif hparams.position_start_index == 'random':
index = tf.random_uniform([], maxval=common_layers.shape_list(x)[1], dtype=tf.int32)
elif hparams.position_start_index == 'step':
num_steps ... | ['def', 'add_position_timing_signal(x,', 'step,', 'hparams):', 'if', 'not', 'hparams.position_start_index:', 'index', '=', '0', 'elif', 'hparams.position_start_index', '==', "'random':", 'index', '=', 'tf.random_uniform([],', 'maxval=common_layers.shape_list(x)[1],', 'dtype=tf.int32)', 'elif', 'hparams.position_start_i... | 965,920 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vqa_attention.py | image_encoder | image_encoder | A stack of self attention layers. | [
"A",
"stack",
"of",
"self",
"attention",
"layers."
] | def image_encoder(image_feat, hparams, name='image_encoder', save_weights_to=None, make_image_summary=True):
x = image_feat
with tf.variable_scope(name):
for layer in range(hparams.num_encoder_layers or hparams.num_hidden_layers):
with tf.variable_scope('layer_%d' % layer):
w... | ['def', 'image_encoder(image_feat,', 'hparams,', "name='image_encoder',", 'save_weights_to=None,', 'make_image_summary=True):', 'x', '=', 'image_feat', 'with', 'tf.variable_scope(name):', 'for', 'layer', 'in', 'range(hparams.num_encoder_layers', 'or', 'hparams.num_hidden_layers):', 'with', "tf.variable_scope('layer_%d'... | 965,922 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vqa_attention.py | attn | attn | Attention on image feature with question as query. | [
"Attention",
"on",
"image",
"feature",
"with",
"question",
"as",
"query."
] | def attn(image_feat, query, hparams, name='attn'):
with tf.variable_scope(name, 'attn', values=[image_feat, query]):
attn_dim = hparams.attn_dim
num_glimps = hparams.num_glimps
num_channels = common_layers.shape_list(image_feat)[-1]
if len(common_layers.shape_list(image_feat)) == 4:
... | ['def', 'attn(image_feat,', 'query,', 'hparams,', "name='attn'):", 'with', 'tf.variable_scope(name,', "'attn',", 'values=[image_feat,', 'query]):', 'attn_dim', '=', 'hparams.attn_dim', 'num_glimps', '=', 'hparams.num_glimps', 'num_channels', '=', 'common_layers.shape_list(image_feat)[-1]', 'if', 'len(common_layers.shap... | 965,924 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vqa_attention.py | mlp | mlp | Multi layer perceptron with dropout and relu activation. | [
"Multi",
"layer",
"perceptron",
"with",
"dropout",
"and",
"relu",
"activation."
] | def mlp(feature, hparams, name='mlp'):
with tf.variable_scope(name, 'mlp', values=[feature]):
num_mlp_layers = hparams.num_mlp_layers
mlp_dim = hparams.mlp_dim
for _ in range(num_mlp_layers):
feature = common_layers.dense(feature, mlp_dim, activation=tf.nn.relu)
featu... | ['def', 'mlp(feature,', 'hparams,', "name='mlp'):", 'with', 'tf.variable_scope(name,', "'mlp',", 'values=[feature]):', 'num_mlp_layers', '=', 'hparams.num_mlp_layers', 'mlp_dim', '=', 'hparams.mlp_dim', 'for', '_', 'in', 'range(num_mlp_layers):', 'feature', '=', 'common_layers.dense(feature,', 'mlp_dim,', 'activation=t... | 965,925 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | vqa_recurrent_self_attention.py | vqa_recurrent_self_attention_base | vqa_recurrent_self_attention_base | VQA attention baseline hparams. | [
"VQA",
"attention",
"baseline",
"hparams."
] | def vqa_recurrent_self_attention_base():
hparams = universal_transformer.universal_transformer_base()
hparams.batch_size = 1024
hparams.use_fixed_batch_size = True
hparams.weight_decay = 0.0
hparams.clip_grad_norm = 0.0
hparams.learning_rate_schedule = 'constant*linear_warmup*rsqrt_normalized_de... | ['def', 'vqa_recurrent_self_attention_base():', 'hparams', '=', 'universal_transformer.universal_transformer_base()', 'hparams.batch_size', '=', '1024', 'hparams.use_fixed_batch_size', '=', 'True', 'hparams.weight_decay', '=', '0.0', 'hparams.clip_grad_norm', '=', '0.0', 'hparams.learning_rate_schedule', '=', "'constan... | 965,928 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | base_vae.py | NextFrameBaseVae.construct_latent_tower | construct_latent_tower | Create the latent tower. | [
"Create",
"the",
"latent",
"tower."
] | def construct_latent_tower(self, images, time_axis):
first_phase = tf.less(self.get_iteration_num(), self.hparams.num_iterations_1st_stage)
latent_num_frames = self.hparams.latent_num_frames
tf.logging.info('Creating latent tower with %d frames.' % latent_num_frames)
if latent_num_frames > 0:
im... | ['def', 'construct_latent_tower(self,', 'images,', 'time_axis):', 'first_phase', '=', 'tf.less(self.get_iteration_num(),', 'self.hparams.num_iterations_1st_stage)', 'latent_num_frames', '=', 'self.hparams.latent_num_frames', "tf.logging.info('Creating", 'latent', 'tower', 'with', '%d', "frames.'", '%', 'latent_num_fram... | 965,937 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic.py | NextFrameBasicDeterministic.inject_latent | inject_latent | Do nothing for deterministic model. | [
"Do",
"nothing",
"for",
"deterministic",
"model."
] | def inject_latent(self, layer, features, filters):
del features, filters
return (layer, 0.0) | ['def', 'inject_latent(self,', 'layer,', 'features,', 'filters):', 'del', 'features,', 'filters', 'return', '(layer,', '0.0)'] | 965,938 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic.py | NextFrameBasicDeterministic.infer | infer | Produce predictions from the model by running it. | [
"Produce",
"predictions",
"from",
"the",
"model",
"by",
"running",
"it."
] | def infer(self, features, *args, **kwargs):
del args, kwargs
if not features:
features = {}
inputs_old = None
if 'inputs' in features and len(features['inputs'].shape) < 4:
inputs_old = features['inputs']
features['inputs'] = tf.expand_dims(features['inputs'], 2)
def logits_... | ['def', 'infer(self,', 'features,', '*args,', '**kwargs):', 'del', 'args,', 'kwargs', 'if', 'not', 'features:', 'features', '=', '{}', 'inputs_old', '=', 'None', 'if', "'inputs'", 'in', 'features', 'and', "len(features['inputs'].shape)", '<', '4:', 'inputs_old', '=', "features['inputs']", "features['inputs']", '=', "tf... | 965,939 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic_params.py | next_frame_basic_deterministic | next_frame_basic_deterministic | Basic 2-frame conv model. | [
"Basic",
"2-frame",
"conv",
"model."
] | def next_frame_basic_deterministic():
hparams = common_hparams.basic_params1()
hparams.video_num_input_frames = 4
hparams.video_num_target_frames = 1
hparams.hidden_size = 64
hparams.batch_size = 4
hparams.num_hidden_layers = 2
hparams.optimizer = 'Adafactor'
hparams.learning_rate_consta... | ['def', 'next_frame_basic_deterministic():', 'hparams', '=', 'common_hparams.basic_params1()', 'hparams.video_num_input_frames', '=', '4', 'hparams.video_num_target_frames', '=', '1', 'hparams.hidden_size', '=', '64', 'hparams.batch_size', '=', '4', 'hparams.num_hidden_layers', '=', '2', 'hparams.optimizer', '=', "'Ada... | 965,940 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic_params.py | next_frame_pixel_noise | next_frame_pixel_noise | Basic 2-frame conv model with pixel noise. | [
"Basic",
"2-frame",
"conv",
"model",
"with",
"pixel",
"noise."
] | def next_frame_pixel_noise():
hparams = next_frame_basic_deterministic()
hparams.add_hparam('video_modality_input_noise', 0.05)
hparams.input_modalities = 'inputs:video:pixel_noise'
return hparams | ['def', 'next_frame_pixel_noise():', 'hparams', '=', 'next_frame_basic_deterministic()', "hparams.add_hparam('video_modality_input_noise',", '0.05)', 'hparams.input_modalities', '=', "'inputs:video:pixel_noise'", 'return', 'hparams'] | 965,941 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic_params.py | next_frame_sampling | next_frame_sampling | Basic conv model with scheduled sampling. | [
"Basic",
"conv",
"model",
"with",
"scheduled",
"sampling."
] | def next_frame_sampling():
hparams = next_frame_basic_deterministic()
hparams.video_num_target_frames = 2
hparams.scheduled_sampling_warmup_steps = 50000
hparams.scheduled_sampling_prob = 0.5
return hparams | ['def', 'next_frame_sampling():', 'hparams', '=', 'next_frame_basic_deterministic()', 'hparams.video_num_target_frames', '=', '2', 'hparams.scheduled_sampling_warmup_steps', '=', '50000', 'hparams.scheduled_sampling_prob', '=', '0.5', 'return', 'hparams'] | 965,942 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic_params.py | next_frame_l1 | next_frame_l1 | Basic conv model with L1 modality. | [
"Basic",
"conv",
"model",
"with",
"L1",
"modality."
] | def next_frame_l1():
hparams = next_frame_basic_deterministic()
hparams.target_modality = 'video:l1'
hparams.video_modality_loss_cutoff = 2.4
return hparams | ['def', 'next_frame_l1():', 'hparams', '=', 'next_frame_basic_deterministic()', 'hparams.target_modality', '=', "'video:l1'", 'hparams.video_modality_loss_cutoff', '=', '2.4', 'return', 'hparams'] | 965,943 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_deterministic_params.py | next_frame_l2 | next_frame_l2 | Basic conv model with L2 modality. | [
"Basic",
"conv",
"model",
"with",
"L2",
"modality."
] | def next_frame_l2():
hparams = next_frame_basic_deterministic()
hparams.target_modality = 'video:l2'
hparams.video_modality_loss_cutoff = 2.4
return hparams | ['def', 'next_frame_l2():', 'hparams', '=', 'next_frame_basic_deterministic()', 'hparams.target_modality', '=', "'video:l2'", 'hparams.video_modality_loss_cutoff', '=', '2.4', 'return', 'hparams'] | 965,944 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_stochastic.py | next_frame_basic_stochastic | next_frame_basic_stochastic | Basic 2-frame conv model with stochastic tower. | [
"Basic",
"2-frame",
"conv",
"model",
"with",
"stochastic",
"tower."
] | def next_frame_basic_stochastic():
hparams = basic_deterministic_params.next_frame_basic_deterministic()
hparams.stochastic_model = True
hparams.add_hparam('latent_channels', 1)
hparams.add_hparam('latent_std_min', -5.0)
hparams.add_hparam('num_iterations_1st_stage', 25000)
hparams.add_hparam('n... | ['def', 'next_frame_basic_stochastic():', 'hparams', '=', 'basic_deterministic_params.next_frame_basic_deterministic()', 'hparams.stochastic_model', '=', 'True', "hparams.add_hparam('latent_channels',", '1)', "hparams.add_hparam('latent_std_min',", '-5.0)', "hparams.add_hparam('num_iterations_1st_stage',", '25000)', "h... | 965,948 |
hongliangduan/Transformer-model-for-prediction-in-low-chemical-data-regimes | basic_stochastic.py | next_frame_basic_stochastic_discrete | next_frame_basic_stochastic_discrete | Basic 2-frame conv model with stochastic discrete latent. | [
"Basic",
"2-frame",
"conv",
"model",
"with",
"stochastic",
"discrete",
"latent."
] | def next_frame_basic_stochastic_discrete():
hparams = basic_deterministic_params.next_frame_basic_deterministic()
hparams.num_compress_steps = 8
hparams.filter_double_steps = 3
hparams.add_hparam('bottleneck_bits', 32)
hparams.add_hparam('bottleneck_noise', 0.05)
return hparams | ['def', 'next_frame_basic_stochastic_discrete():', 'hparams', '=', 'basic_deterministic_params.next_frame_basic_deterministic()', 'hparams.num_compress_steps', '=', '8', 'hparams.filter_double_steps', '=', '3', "hparams.add_hparam('bottleneck_bits',", '32)', "hparams.add_hparam('bottleneck_noise',", '0.05)', 'return', ... | 965,949 |
sek788432/Waymo-2D-Object-Detection | gaussian_process_test.py | GaussianProcessTest.test_laplace_covariance_minibatch | test_laplace_covariance_minibatch | Tests if model correctly learns population-lvel precision matrix. | [
"Tests",
"if",
"model",
"correctly",
"learns",
"population-lvel",
"precision",
"matrix."
] | def test_laplace_covariance_minibatch(self, generate_orthogonal_data):
batch_size = 50
epochs = 1000
x_data = _generate_rbf_data(self.x_ts, generate_orthogonal_data)
data_iterator = _make_minibatch_iterator(x_data, batch_size, epochs)
cov_estimator = gaussian_process.LaplaceRandomFeatureCovariance(m... | ['def', 'test_laplace_covariance_minibatch(self,', 'generate_orthogonal_data):', 'batch_size', '=', '50', 'epochs', '=', '1000', 'x_data', '=', '_generate_rbf_data(self.x_ts,', 'generate_orthogonal_data)', 'data_iterator', '=', '_make_minibatch_iterator(x_data,', 'batch_size,', 'epochs)', 'cov_estimator', '=', 'gaussia... | 972,570 |
sek788432/Waymo-2D-Object-Detection | gaussian_process_test.py | GaussianProcessTest.test_random_feature_posterior_approximation | test_random_feature_posterior_approximation | Tests random feature GP's ability in approximating exact GP posterior. | [
"Tests",
"random",
"feature",
"GP's",
"ability",
"in",
"approximating",
"exact",
"GP",
"posterior."
] | def test_random_feature_posterior_approximation(self):
gp_cov_momentum = 0.5
gp_cov_ridge_penalty = 1.0
num_inducing = 1024
rfgp_model = gaussian_process.RandomFeatureGaussianProcess(units=1, num_inducing=num_inducing, normalize_input=False, gp_kernel_type='gaussian', gp_cov_momentum=gp_cov_momentum, gp... | ['def', 'test_random_feature_posterior_approximation(self):', 'gp_cov_momentum', '=', '0.5', 'gp_cov_ridge_penalty', '=', '1.0', 'num_inducing', '=', '1024', 'rfgp_model', '=', 'gaussian_process.RandomFeatureGaussianProcess(units=1,', 'num_inducing=num_inducing,', 'normalize_input=False,', "gp_kernel_type='gaussian',",... | 972,572 |
sek788432/Waymo-2D-Object-Detection | gaussian_process_test.py | GaussianProcessTest.test_no_matrix_update_during_test | test_no_matrix_update_during_test | Tests if the precision matrix is not updated during testing. | [
"Tests",
"if",
"the",
"precision",
"matrix",
"is",
"not",
"updated",
"during",
"testing."
] | def test_no_matrix_update_during_test(self):
rfgp_model = gaussian_process.RandomFeatureGaussianProcess(units=1)
(_, gp_covmat_null) = rfgp_model(self.x_tr, training=True)
precision_mat_before_test = rfgp_model._gp_cov_layer.precision_matrix
_ = rfgp_model(self.x_ts, training=False)
precision_mat_af... | ['def', 'test_no_matrix_update_during_test(self):', 'rfgp_model', '=', 'gaussian_process.RandomFeatureGaussianProcess(units=1)', '(_,', 'gp_covmat_null)', '=', 'rfgp_model(self.x_tr,', 'training=True)', 'precision_mat_before_test', '=', 'rfgp_model._gp_cov_layer.precision_matrix', '_', '=', 'rfgp_model(self.x_ts,', 'tr... | 972,574 |
sek788432/Waymo-2D-Object-Detection | gaussian_process_test.py | GaussianProcessTest.test_state_saving_and_loading | test_state_saving_and_loading | Tests if the loaded model returns same results. | [
"Tests",
"if",
"the",
"loaded",
"model",
"returns",
"same",
"results."
] | def test_state_saving_and_loading(self):
input_data = np.random.random((1, 2))
rfgp_model = gaussian_process.RandomFeatureGaussianProcess(units=1)
inputs = tf.keras.Input((2,), batch_size=1)
outputs = rfgp_model(inputs)
model = tf.keras.Model(inputs, outputs)
(gp_output, gp_covmat) = model.predi... | ['def', 'test_state_saving_and_loading(self):', 'input_data', '=', 'np.random.random((1,', '2))', 'rfgp_model', '=', 'gaussian_process.RandomFeatureGaussianProcess(units=1)', 'inputs', '=', 'tf.keras.Input((2,),', 'batch_size=1)', 'outputs', '=', 'rfgp_model(inputs)', 'model', '=', 'tf.keras.Model(inputs,', 'outputs)',... | 972,575 |
sek788432/Waymo-2D-Object-Detection | gaussian_process_test.py | MeanFieldLogitsTest.testMeanFieldLogitsTemperatureScaling | testMeanFieldLogitsTemperatureScaling | Tests using mean_field_logits as temperature scaling method. | [
"Tests",
"using",
"mean_field_logits",
"as",
"temperature",
"scaling",
"method."
] | def testMeanFieldLogitsTemperatureScaling(self):
batch_size = 10
num_classes = 12
rng = np.random.RandomState(0)
tf.random.set_seed(1)
logits = rng.randn(batch_size, num_classes)
logits_no_change = gaussian_process.mean_field_logits(logits, covariance_matrix=None, mean_field_factor=-1)
logit... | ['def', 'testMeanFieldLogitsTemperatureScaling(self):', 'batch_size', '=', '10', 'num_classes', '=', '12', 'rng', '=', 'np.random.RandomState(0)', 'tf.random.set_seed(1)', 'logits', '=', 'rng.randn(batch_size,', 'num_classes)', 'logits_no_change', '=', 'gaussian_process.mean_field_logits(logits,', 'covariance_matrix=No... | 972,577 |
sek788432/Waymo-2D-Object-Detection | mobile_bert_layers.py | MobileBertTransformer.call | call | Implementes the forward pass. | [
"Implementes",
"the",
"forward",
"pass."
] | def call(self, input_tensor, attention_mask=None, return_attention_scores=False):
input_width = input_tensor.shape.as_list()[-1]
if input_width != self.hidden_size:
raise ValueError(f'The width of the input tensor {input_width} != hidden size {self.hidden_size}')
prev_output = input_tensor
dense... | ['def', 'call(self,', 'input_tensor,', 'attention_mask=None,', 'return_attention_scores=False):', 'input_width', '=', 'input_tensor.shape.as_list()[-1]', 'if', 'input_width', '!=', 'self.hidden_size:', 'raise', "ValueError(f'The", 'width', 'of', 'the', 'input', 'tensor', '{input_width}', '!=', 'hidden', 'size', "{self.... | 972,581 |
sek788432/Waymo-2D-Object-Detection | mobile_bert_layers_test.py | generate_fake_input | generate_fake_input | Generate consistent fake integer input sequences. | [
"Generate",
"consistent",
"fake",
"integer",
"input",
"sequences."
] | def generate_fake_input(batch_size=1, seq_len=5, vocab_size=10000, seed=0):
np.random.seed(seed)
fake_input = []
for _ in range(batch_size):
fake_input.append([])
for _ in range(seq_len):
fake_input[-1].append(np.random.randint(0, vocab_size))
fake_input = np.asarray(fake_inp... | ['def', 'generate_fake_input(batch_size=1,', 'seq_len=5,', 'vocab_size=10000,', 'seed=0):', 'np.random.seed(seed)', 'fake_input', '=', '[]', 'for', '_', 'in', 'range(batch_size):', 'fake_input.append([])', 'for', '_', 'in', 'range(seq_len):', 'fake_input[-1].append(np.random.randint(0,', 'vocab_size))', 'fake_input', '... | 972,582 |
sek788432/Waymo-2D-Object-Detection | spectral_normalization.py | SpectralNormalization.restore_weights | restore_weights | Restores layer weights to maintain gradient update (See Alg 1 of [1]). | [
"Restores",
"layer",
"weights",
"to",
"maintain",
"gradient",
"update",
"(See",
"Alg",
"1",
"of",
"[1])."
] | def restore_weights(self):
return self.layer.kernel.assign(self.w) | ['def', 'restore_weights(self):', 'return', 'self.layer.kernel.assign(self.w)'] | 972,590 |
sek788432/Waymo-2D-Object-Detection | spectral_normalization.py | SpectralNormalizationConv2D.update_weights | update_weights | Computes power iteration for convolutional filters based on [3]. | [
"Computes",
"power",
"iteration",
"for",
"convolutional",
"filters",
"based",
"on",
"[3]."
] | def update_weights(self):
u_hat = self.u
v_hat = self.v
if self.do_power_iteration:
for _ in range(self.iteration):
v_ = tf.nn.conv2d_transpose(u_hat, self.w, output_shape=self.in_shape, strides=self.strides, padding='SAME')
v_hat = tf.nn.l2_normalize(tf.reshape(v_, [1, -1]))... | ['def', 'update_weights(self):', 'u_hat', '=', 'self.u', 'v_hat', '=', 'self.v', 'if', 'self.do_power_iteration:', 'for', '_', 'in', 'range(self.iteration):', 'v_', '=', 'tf.nn.conv2d_transpose(u_hat,', 'self.w,', 'output_shape=self.in_shape,', 'strides=self.strides,', "padding='SAME')", 'v_hat', '=', 'tf.nn.l2_normali... | 972,591 |
sek788432/Waymo-2D-Object-Detection | spectral_normalization_test.py | NormalizationTest.test_spec_norm_magnitude | test_spec_norm_magnitude | Tests if the weights spectral norm converges to norm_multiplier. | [
"Tests",
"if",
"the",
"weights",
"spectral",
"norm",
"converges",
"to",
"norm_multiplier."
] | def test_spec_norm_magnitude(self, input_shape, layer, norm_wrapper):
layer.build(input_shape)
sn_layer = norm_wrapper(layer, iteration=self.num_iterations, norm_multiplier=self.norm_multiplier)
sn_layer.build(input_shape)
sn_layer.update_weights()
normalized_kernel = sn_layer.layer.kernel.numpy()
... | ['def', 'test_spec_norm_magnitude(self,', 'input_shape,', 'layer,', 'norm_wrapper):', 'layer.build(input_shape)', 'sn_layer', '=', 'norm_wrapper(layer,', 'iteration=self.num_iterations,', 'norm_multiplier=self.norm_multiplier)', 'sn_layer.build(input_shape)', 'sn_layer.update_weights()', 'normalized_kernel', '=', 'sn_l... | 972,593 |
sek788432/Waymo-2D-Object-Detection | talking_heads_attention_test.py | TalkingHeadsAttentionTest.test_non_masked_attention | test_non_masked_attention | Test that the attention layer can be created without a mask tensor. | [
"Test",
"that",
"the",
"attention",
"layer",
"can",
"be",
"created",
"without",
"a",
"mask",
"tensor."
] | def test_non_masked_attention(self, value_dim, output_shape, output_dims):
test_layer = talking_heads_attention.TalkingHeadsAttention(num_heads=12, key_dim=64, value_dim=value_dim, output_shape=output_shape)
query = tf.keras.Input(shape=(40, 80))
value = tf.keras.Input(shape=(20, 80))
output = test_laye... | ['def', 'test_non_masked_attention(self,', 'value_dim,', 'output_shape,', 'output_dims):', 'test_layer', '=', 'talking_heads_attention.TalkingHeadsAttention(num_heads=12,', 'key_dim=64,', 'value_dim=value_dim,', 'output_shape=output_shape)', 'query', '=', 'tf.keras.Input(shape=(40,', '80))', 'value', '=', 'tf.keras.Inp... | 972,594 |
sek788432/Waymo-2D-Object-Detection | text_layers_test.py | BertTokenizerTest.test_special_tokens_in_estimator | test_special_tokens_in_estimator | Tests getting special tokens without an Eager init context. | [
"Tests",
"getting",
"special",
"tokens",
"without",
"an",
"Eager",
"init",
"context."
] | def test_special_tokens_in_estimator(self):
vocab_file = self._make_vocab_file(['[PAD]', '[UNK]', '[CLS]', '[SEP]', 'd', '##ef', 'abc', 'xy'])
def input_fn():
with tf.init_scope():
self.assertFalse(tf.executing_eagerly())
sentences = tf.keras.layers.Input(shape=[], dtype=tf.string)
... | ['def', 'test_special_tokens_in_estimator(self):', 'vocab_file', '=', "self._make_vocab_file(['[PAD]',", "'[UNK]',", "'[CLS]',", "'[SEP]',", "'d',", "'##ef',", "'abc',", "'xy'])", 'def', 'input_fn():', 'with', 'tf.init_scope():', 'self.assertFalse(tf.executing_eagerly())', 'sentences', '=', 'tf.keras.layers.Input(shape... | 972,607 |
sek788432/Waymo-2D-Object-Detection | transformer.py | TransformerDecoderBlock.common_layers_with_encoder | common_layers_with_encoder | Gets layer objects that can make a Transformer encoder block. | [
"Gets",
"layer",
"objects",
"that",
"can",
"make",
"a",
"Transformer",
"encoder",
"block."
] | def common_layers_with_encoder(self):
return [self.self_attention, self.self_attention_layer_norm, self.intermediate_dense, self.output_dense, self.output_layer_norm] | ['def', 'common_layers_with_encoder(self):', 'return', '[self.self_attention,', 'self.self_attention_layer_norm,', 'self.intermediate_dense,', 'self.output_dense,', 'self.output_layer_norm]'] | 972,610 |
sek788432/Waymo-2D-Object-Detection | transformer_xl.py | TransformerXLBlock.call | call | Implements `call` for the Layer. | [
"Implements",
"`call`",
"for",
"the",
"Layer."
] | def call(self, content_stream, content_attention_bias, positional_attention_bias, relative_position_encoding=None, segment_matrix=None, segment_encoding=None, segment_attention_bias=None, state=None, content_attention_mask=None, query_stream=None, query_attention_mask=None, target_mapping=None):
if not self._two_st... | ['def', 'call(self,', 'content_stream,', 'content_attention_bias,', 'positional_attention_bias,', 'relative_position_encoding=None,', 'segment_matrix=None,', 'segment_encoding=None,', 'segment_attention_bias=None,', 'state=None,', 'content_attention_mask=None,', 'query_stream=None,', 'query_attention_mask=None,', 'targ... | 972,611 |
sek788432/Waymo-2D-Object-Detection | xlnet_base.py | XLNetBase.get_embedding_lookup_table | get_embedding_lookup_table | Returns the embedding layer weights. | [
"Returns",
"the",
"embedding",
"layer",
"weights."
] | def get_embedding_lookup_table(self):
return self._embedding_layer.embeddings | ['def', 'get_embedding_lookup_table(self):', 'return', 'self._embedding_layer.embeddings'] | 972,686 |
sek788432/Waymo-2D-Object-Detection | beam_search.py | flatten_beam_dim | flatten_beam_dim | Reshapes first two dimensions into a single dimension. | [
"Reshapes",
"first",
"two",
"dimensions",
"into",
"a",
"single",
"dimension."
] | def flatten_beam_dim(tensor):
shape = _shape_list(tensor)
shape[0] *= shape[1]
shape.pop(1)
return tf.reshape(tensor, shape) | ['def', 'flatten_beam_dim(tensor):', 'shape', '=', '_shape_list(tensor)', 'shape[0]', '*=', 'shape[1]', 'shape.pop(1)', 'return', 'tf.reshape(tensor,', 'shape)'] | 972,697 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.