repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/adafactor_experiments.py
|
afx_adafactor
|
def afx_adafactor():
"""Adafactor with recommended learning rate schedule."""
hparams = afx_adam()
hparams.optimizer = "Adafactor"
hparams.learning_rate_schedule = "rsqrt_decay"
hparams.learning_rate_warmup_steps = 10000
return hparams
|
python
|
def afx_adafactor():
"""Adafactor with recommended learning rate schedule."""
hparams = afx_adam()
hparams.optimizer = "Adafactor"
hparams.learning_rate_schedule = "rsqrt_decay"
hparams.learning_rate_warmup_steps = 10000
return hparams
|
[
"def",
"afx_adafactor",
"(",
")",
":",
"hparams",
"=",
"afx_adam",
"(",
")",
"hparams",
".",
"optimizer",
"=",
"\"Adafactor\"",
"hparams",
".",
"learning_rate_schedule",
"=",
"\"rsqrt_decay\"",
"hparams",
".",
"learning_rate_warmup_steps",
"=",
"10000",
"return",
"hparams"
] |
Adafactor with recommended learning rate schedule.
|
[
"Adafactor",
"with",
"recommended",
"learning",
"rate",
"schedule",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/adafactor_experiments.py#L167-L173
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/adafactor_experiments.py
|
afx_small
|
def afx_small():
"""Small transformer model with small batch size for fast step times."""
hparams = transformer.transformer_tpu()
hparams.filter_size = 1024
hparams.num_heads = 4
hparams.num_hidden_layers = 3
hparams.batch_size = 512
return hparams
|
python
|
def afx_small():
"""Small transformer model with small batch size for fast step times."""
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"
] |
Small transformer model with small batch size for fast step times.
|
[
"Small",
"transformer",
"model",
"with",
"small",
"batch",
"size",
"for",
"fast",
"step",
"times",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/adafactor_experiments.py#L177-L184
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/video/emily.py
|
next_frame_emily
|
def next_frame_emily():
"""Emily's model hparams."""
hparams = sv2p_params.next_frame_sv2p()
hparams.video_num_input_frames = 2
hparams.video_num_target_frames = 10
hparams.learning_rate_constant = 1e-4
seq_length = hparams.video_num_input_frames + hparams.video_num_target_frames
# The latent_loss_multiplier is divided by the number of frames because
# the image sequence loss in t2t is averaged instead of added through
# time as they do in the SVG-LP paper
hparams.latent_loss_multiplier = 1e-4 / seq_length
hparams.reward_prediction = False
hparams.num_iterations_1st_stage = -1
hparams.num_iterations_2nd_stage = -1
hparams.optimizer_adam_beta1 = 0.9
hparams.optimizer_adam_beta2 = 0.999
hparams.optimizer_adam_epsilon = 1e-08
hparams.anneal_end = -1
hparams.clip_grad_norm = 5.0
hparams.add_hparam("learned_prior", True)
hparams.add_hparam("z_dim", 64)
hparams.add_hparam("g_dim", 128)
hparams.add_hparam("rnn_size", 256)
hparams.add_hparam("prior_rnn_layers", 1)
hparams.add_hparam("posterior_rnn_layers", 1)
hparams.add_hparam("predictor_rnn_layers", 2)
hparams.add_hparam("has_skips", True)
hparams.add_hparam("has_batchnorm", True)
return hparams
|
python
|
def next_frame_emily():
"""Emily's model hparams."""
hparams = sv2p_params.next_frame_sv2p()
hparams.video_num_input_frames = 2
hparams.video_num_target_frames = 10
hparams.learning_rate_constant = 1e-4
seq_length = hparams.video_num_input_frames + hparams.video_num_target_frames
# The latent_loss_multiplier is divided by the number of frames because
# the image sequence loss in t2t is averaged instead of added through
# time as they do in the SVG-LP paper
hparams.latent_loss_multiplier = 1e-4 / seq_length
hparams.reward_prediction = False
hparams.num_iterations_1st_stage = -1
hparams.num_iterations_2nd_stage = -1
hparams.optimizer_adam_beta1 = 0.9
hparams.optimizer_adam_beta2 = 0.999
hparams.optimizer_adam_epsilon = 1e-08
hparams.anneal_end = -1
hparams.clip_grad_norm = 5.0
hparams.add_hparam("learned_prior", True)
hparams.add_hparam("z_dim", 64)
hparams.add_hparam("g_dim", 128)
hparams.add_hparam("rnn_size", 256)
hparams.add_hparam("prior_rnn_layers", 1)
hparams.add_hparam("posterior_rnn_layers", 1)
hparams.add_hparam("predictor_rnn_layers", 2)
hparams.add_hparam("has_skips", True)
hparams.add_hparam("has_batchnorm", True)
return hparams
|
[
"def",
"next_frame_emily",
"(",
")",
":",
"hparams",
"=",
"sv2p_params",
".",
"next_frame_sv2p",
"(",
")",
"hparams",
".",
"video_num_input_frames",
"=",
"2",
"hparams",
".",
"video_num_target_frames",
"=",
"10",
"hparams",
".",
"learning_rate_constant",
"=",
"1e-4",
"seq_length",
"=",
"hparams",
".",
"video_num_input_frames",
"+",
"hparams",
".",
"video_num_target_frames",
"# The latent_loss_multiplier is divided by the number of frames because",
"# the image sequence loss in t2t is averaged instead of added through",
"# time as they do in the SVG-LP paper",
"hparams",
".",
"latent_loss_multiplier",
"=",
"1e-4",
"/",
"seq_length",
"hparams",
".",
"reward_prediction",
"=",
"False",
"hparams",
".",
"num_iterations_1st_stage",
"=",
"-",
"1",
"hparams",
".",
"num_iterations_2nd_stage",
"=",
"-",
"1",
"hparams",
".",
"optimizer_adam_beta1",
"=",
"0.9",
"hparams",
".",
"optimizer_adam_beta2",
"=",
"0.999",
"hparams",
".",
"optimizer_adam_epsilon",
"=",
"1e-08",
"hparams",
".",
"anneal_end",
"=",
"-",
"1",
"hparams",
".",
"clip_grad_norm",
"=",
"5.0",
"hparams",
".",
"add_hparam",
"(",
"\"learned_prior\"",
",",
"True",
")",
"hparams",
".",
"add_hparam",
"(",
"\"z_dim\"",
",",
"64",
")",
"hparams",
".",
"add_hparam",
"(",
"\"g_dim\"",
",",
"128",
")",
"hparams",
".",
"add_hparam",
"(",
"\"rnn_size\"",
",",
"256",
")",
"hparams",
".",
"add_hparam",
"(",
"\"prior_rnn_layers\"",
",",
"1",
")",
"hparams",
".",
"add_hparam",
"(",
"\"posterior_rnn_layers\"",
",",
"1",
")",
"hparams",
".",
"add_hparam",
"(",
"\"predictor_rnn_layers\"",
",",
"2",
")",
"hparams",
".",
"add_hparam",
"(",
"\"has_skips\"",
",",
"True",
")",
"hparams",
".",
"add_hparam",
"(",
"\"has_batchnorm\"",
",",
"True",
")",
"return",
"hparams"
] |
Emily's model hparams.
|
[
"Emily",
"s",
"model",
"hparams",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/video/emily.py#L447-L475
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/inspect_tfrecord.py
|
main
|
def main(_):
"""Convert a file to examples."""
if FLAGS.subword_text_encoder_filename:
encoder = text_encoder.SubwordTextEncoder(
FLAGS.subword_text_encoder_filename)
elif FLAGS.token_text_encoder_filename:
encoder = text_encoder.TokenTextEncoder(FLAGS.token_text_encoder_filename)
elif FLAGS.byte_text_encoder:
encoder = text_encoder.ByteTextEncoder()
else:
encoder = None
reader = tf.python_io.tf_record_iterator(FLAGS.input_filename)
total_sequences = 0
total_input_tokens = 0
total_target_tokens = 0
nonpadding_input_tokens = 0
nonpadding_target_tokens = 0
max_input_length = 0
max_target_length = 0
for record in reader:
x = tf.train.Example()
x.ParseFromString(record)
inputs = [int(i) for i in x.features.feature["inputs"].int64_list.value]
targets = [int(i) for i in x.features.feature["targets"].int64_list.value]
if FLAGS.print_inputs:
print("INPUTS:\n" + encoder.decode(inputs) if encoder else inputs)
if FLAGS.print_targets:
print("TARGETS:\n" + encoder.decode(targets) if encoder else targets)
nonpadding_input_tokens += len(inputs) - inputs.count(0)
nonpadding_target_tokens += len(targets) - targets.count(0)
total_input_tokens += len(inputs)
total_target_tokens += len(targets)
total_sequences += 1
max_input_length = max(max_input_length, len(inputs))
max_target_length = max(max_target_length, len(targets))
if FLAGS.print_all:
for k, v in six.iteritems(x.features.feature):
print("%s: %s" % (k, v.int64_list.value))
print("total_sequences: %d" % total_sequences)
print("total_input_tokens: %d" % total_input_tokens)
print("total_target_tokens: %d" % total_target_tokens)
print("nonpadding_input_tokens: %d" % nonpadding_input_tokens)
print("nonpadding_target_tokens: %d" % nonpadding_target_tokens)
print("max_input_length: %d" % max_input_length)
print("max_target_length: %d" % max_target_length)
|
python
|
def main(_):
"""Convert a file to examples."""
if FLAGS.subword_text_encoder_filename:
encoder = text_encoder.SubwordTextEncoder(
FLAGS.subword_text_encoder_filename)
elif FLAGS.token_text_encoder_filename:
encoder = text_encoder.TokenTextEncoder(FLAGS.token_text_encoder_filename)
elif FLAGS.byte_text_encoder:
encoder = text_encoder.ByteTextEncoder()
else:
encoder = None
reader = tf.python_io.tf_record_iterator(FLAGS.input_filename)
total_sequences = 0
total_input_tokens = 0
total_target_tokens = 0
nonpadding_input_tokens = 0
nonpadding_target_tokens = 0
max_input_length = 0
max_target_length = 0
for record in reader:
x = tf.train.Example()
x.ParseFromString(record)
inputs = [int(i) for i in x.features.feature["inputs"].int64_list.value]
targets = [int(i) for i in x.features.feature["targets"].int64_list.value]
if FLAGS.print_inputs:
print("INPUTS:\n" + encoder.decode(inputs) if encoder else inputs)
if FLAGS.print_targets:
print("TARGETS:\n" + encoder.decode(targets) if encoder else targets)
nonpadding_input_tokens += len(inputs) - inputs.count(0)
nonpadding_target_tokens += len(targets) - targets.count(0)
total_input_tokens += len(inputs)
total_target_tokens += len(targets)
total_sequences += 1
max_input_length = max(max_input_length, len(inputs))
max_target_length = max(max_target_length, len(targets))
if FLAGS.print_all:
for k, v in six.iteritems(x.features.feature):
print("%s: %s" % (k, v.int64_list.value))
print("total_sequences: %d" % total_sequences)
print("total_input_tokens: %d" % total_input_tokens)
print("total_target_tokens: %d" % total_target_tokens)
print("nonpadding_input_tokens: %d" % nonpadding_input_tokens)
print("nonpadding_target_tokens: %d" % nonpadding_target_tokens)
print("max_input_length: %d" % max_input_length)
print("max_target_length: %d" % max_target_length)
|
[
"def",
"main",
"(",
"_",
")",
":",
"if",
"FLAGS",
".",
"subword_text_encoder_filename",
":",
"encoder",
"=",
"text_encoder",
".",
"SubwordTextEncoder",
"(",
"FLAGS",
".",
"subword_text_encoder_filename",
")",
"elif",
"FLAGS",
".",
"token_text_encoder_filename",
":",
"encoder",
"=",
"text_encoder",
".",
"TokenTextEncoder",
"(",
"FLAGS",
".",
"token_text_encoder_filename",
")",
"elif",
"FLAGS",
".",
"byte_text_encoder",
":",
"encoder",
"=",
"text_encoder",
".",
"ByteTextEncoder",
"(",
")",
"else",
":",
"encoder",
"=",
"None",
"reader",
"=",
"tf",
".",
"python_io",
".",
"tf_record_iterator",
"(",
"FLAGS",
".",
"input_filename",
")",
"total_sequences",
"=",
"0",
"total_input_tokens",
"=",
"0",
"total_target_tokens",
"=",
"0",
"nonpadding_input_tokens",
"=",
"0",
"nonpadding_target_tokens",
"=",
"0",
"max_input_length",
"=",
"0",
"max_target_length",
"=",
"0",
"for",
"record",
"in",
"reader",
":",
"x",
"=",
"tf",
".",
"train",
".",
"Example",
"(",
")",
"x",
".",
"ParseFromString",
"(",
"record",
")",
"inputs",
"=",
"[",
"int",
"(",
"i",
")",
"for",
"i",
"in",
"x",
".",
"features",
".",
"feature",
"[",
"\"inputs\"",
"]",
".",
"int64_list",
".",
"value",
"]",
"targets",
"=",
"[",
"int",
"(",
"i",
")",
"for",
"i",
"in",
"x",
".",
"features",
".",
"feature",
"[",
"\"targets\"",
"]",
".",
"int64_list",
".",
"value",
"]",
"if",
"FLAGS",
".",
"print_inputs",
":",
"print",
"(",
"\"INPUTS:\\n\"",
"+",
"encoder",
".",
"decode",
"(",
"inputs",
")",
"if",
"encoder",
"else",
"inputs",
")",
"if",
"FLAGS",
".",
"print_targets",
":",
"print",
"(",
"\"TARGETS:\\n\"",
"+",
"encoder",
".",
"decode",
"(",
"targets",
")",
"if",
"encoder",
"else",
"targets",
")",
"nonpadding_input_tokens",
"+=",
"len",
"(",
"inputs",
")",
"-",
"inputs",
".",
"count",
"(",
"0",
")",
"nonpadding_target_tokens",
"+=",
"len",
"(",
"targets",
")",
"-",
"targets",
".",
"count",
"(",
"0",
")",
"total_input_tokens",
"+=",
"len",
"(",
"inputs",
")",
"total_target_tokens",
"+=",
"len",
"(",
"targets",
")",
"total_sequences",
"+=",
"1",
"max_input_length",
"=",
"max",
"(",
"max_input_length",
",",
"len",
"(",
"inputs",
")",
")",
"max_target_length",
"=",
"max",
"(",
"max_target_length",
",",
"len",
"(",
"targets",
")",
")",
"if",
"FLAGS",
".",
"print_all",
":",
"for",
"k",
",",
"v",
"in",
"six",
".",
"iteritems",
"(",
"x",
".",
"features",
".",
"feature",
")",
":",
"print",
"(",
"\"%s: %s\"",
"%",
"(",
"k",
",",
"v",
".",
"int64_list",
".",
"value",
")",
")",
"print",
"(",
"\"total_sequences: %d\"",
"%",
"total_sequences",
")",
"print",
"(",
"\"total_input_tokens: %d\"",
"%",
"total_input_tokens",
")",
"print",
"(",
"\"total_target_tokens: %d\"",
"%",
"total_target_tokens",
")",
"print",
"(",
"\"nonpadding_input_tokens: %d\"",
"%",
"nonpadding_input_tokens",
")",
"print",
"(",
"\"nonpadding_target_tokens: %d\"",
"%",
"nonpadding_target_tokens",
")",
"print",
"(",
"\"max_input_length: %d\"",
"%",
"max_input_length",
")",
"print",
"(",
"\"max_target_length: %d\"",
"%",
"max_target_length",
")"
] |
Convert a file to examples.
|
[
"Convert",
"a",
"file",
"to",
"examples",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/inspect_tfrecord.py#L48-L93
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/envs/rendered_env_problem.py
|
RenderedEnvProblem.example_reading_spec
|
def example_reading_spec(self):
"""Return a mix of env and video data fields and decoders."""
video_fields, video_decoders = (
video_utils.VideoProblem.example_reading_spec(self))
env_fields, env_decoders = env_problem.EnvProblem.example_reading_spec(self)
# Remove raw observations field since we want to capture them as videos.
env_fields.pop(env_problem.OBSERVATION_FIELD)
env_decoders.pop(env_problem.OBSERVATION_FIELD)
# Add frame number spec and decoder.
env_fields[_FRAME_NUMBER_FIELD] = tf.FixedLenFeature((1,), tf.int64)
env_decoders[
_FRAME_NUMBER_FIELD] = tf.contrib.slim.tfexample_decoder.Tensor(
_FRAME_NUMBER_FIELD)
# Add video fields and decoders
env_fields.update(video_fields)
env_decoders.update(video_decoders)
return env_fields, env_decoders
|
python
|
def example_reading_spec(self):
"""Return a mix of env and video data fields and decoders."""
video_fields, video_decoders = (
video_utils.VideoProblem.example_reading_spec(self))
env_fields, env_decoders = env_problem.EnvProblem.example_reading_spec(self)
# Remove raw observations field since we want to capture them as videos.
env_fields.pop(env_problem.OBSERVATION_FIELD)
env_decoders.pop(env_problem.OBSERVATION_FIELD)
# Add frame number spec and decoder.
env_fields[_FRAME_NUMBER_FIELD] = tf.FixedLenFeature((1,), tf.int64)
env_decoders[
_FRAME_NUMBER_FIELD] = tf.contrib.slim.tfexample_decoder.Tensor(
_FRAME_NUMBER_FIELD)
# Add video fields and decoders
env_fields.update(video_fields)
env_decoders.update(video_decoders)
return env_fields, env_decoders
|
[
"def",
"example_reading_spec",
"(",
"self",
")",
":",
"video_fields",
",",
"video_decoders",
"=",
"(",
"video_utils",
".",
"VideoProblem",
".",
"example_reading_spec",
"(",
"self",
")",
")",
"env_fields",
",",
"env_decoders",
"=",
"env_problem",
".",
"EnvProblem",
".",
"example_reading_spec",
"(",
"self",
")",
"# Remove raw observations field since we want to capture them as videos.",
"env_fields",
".",
"pop",
"(",
"env_problem",
".",
"OBSERVATION_FIELD",
")",
"env_decoders",
".",
"pop",
"(",
"env_problem",
".",
"OBSERVATION_FIELD",
")",
"# Add frame number spec and decoder.",
"env_fields",
"[",
"_FRAME_NUMBER_FIELD",
"]",
"=",
"tf",
".",
"FixedLenFeature",
"(",
"(",
"1",
",",
")",
",",
"tf",
".",
"int64",
")",
"env_decoders",
"[",
"_FRAME_NUMBER_FIELD",
"]",
"=",
"tf",
".",
"contrib",
".",
"slim",
".",
"tfexample_decoder",
".",
"Tensor",
"(",
"_FRAME_NUMBER_FIELD",
")",
"# Add video fields and decoders",
"env_fields",
".",
"update",
"(",
"video_fields",
")",
"env_decoders",
".",
"update",
"(",
"video_decoders",
")",
"return",
"env_fields",
",",
"env_decoders"
] |
Return a mix of env and video data fields and decoders.
|
[
"Return",
"a",
"mix",
"of",
"env",
"and",
"video",
"data",
"fields",
"and",
"decoders",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/envs/rendered_env_problem.py#L66-L85
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/envs/rendered_env_problem.py
|
RenderedEnvProblem._generate_time_steps
|
def _generate_time_steps(self, trajectory_list):
"""Transforms time step observations to frames of a video."""
for time_step in env_problem.EnvProblem._generate_time_steps(
self, trajectory_list):
# Convert the rendered observations from numpy to png format.
frame_np = np.array(time_step.pop(env_problem.OBSERVATION_FIELD))
frame_np = frame_np.reshape(
[self.frame_height, self.frame_width, self.num_channels])
# TODO(msaffar) Add support for non RGB rendered environments
frame = png.from_array(frame_np, "RGB", info={"bitdepth": 8})
frame_buffer = six.BytesIO()
frame.save(frame_buffer)
# Put the encoded frame back.
time_step[_IMAGE_ENCODED_FIELD] = [frame_buffer.getvalue()]
time_step[_IMAGE_FORMAT_FIELD] = [_FORMAT]
time_step[_IMAGE_HEIGHT_FIELD] = [self.frame_height]
time_step[_IMAGE_WIDTH_FIELD] = [self.frame_width]
# Add the frame number
time_step[_FRAME_NUMBER_FIELD] = time_step[env_problem.TIMESTEP_FIELD]
yield time_step
|
python
|
def _generate_time_steps(self, trajectory_list):
"""Transforms time step observations to frames of a video."""
for time_step in env_problem.EnvProblem._generate_time_steps(
self, trajectory_list):
# Convert the rendered observations from numpy to png format.
frame_np = np.array(time_step.pop(env_problem.OBSERVATION_FIELD))
frame_np = frame_np.reshape(
[self.frame_height, self.frame_width, self.num_channels])
# TODO(msaffar) Add support for non RGB rendered environments
frame = png.from_array(frame_np, "RGB", info={"bitdepth": 8})
frame_buffer = six.BytesIO()
frame.save(frame_buffer)
# Put the encoded frame back.
time_step[_IMAGE_ENCODED_FIELD] = [frame_buffer.getvalue()]
time_step[_IMAGE_FORMAT_FIELD] = [_FORMAT]
time_step[_IMAGE_HEIGHT_FIELD] = [self.frame_height]
time_step[_IMAGE_WIDTH_FIELD] = [self.frame_width]
# Add the frame number
time_step[_FRAME_NUMBER_FIELD] = time_step[env_problem.TIMESTEP_FIELD]
yield time_step
|
[
"def",
"_generate_time_steps",
"(",
"self",
",",
"trajectory_list",
")",
":",
"for",
"time_step",
"in",
"env_problem",
".",
"EnvProblem",
".",
"_generate_time_steps",
"(",
"self",
",",
"trajectory_list",
")",
":",
"# Convert the rendered observations from numpy to png format.",
"frame_np",
"=",
"np",
".",
"array",
"(",
"time_step",
".",
"pop",
"(",
"env_problem",
".",
"OBSERVATION_FIELD",
")",
")",
"frame_np",
"=",
"frame_np",
".",
"reshape",
"(",
"[",
"self",
".",
"frame_height",
",",
"self",
".",
"frame_width",
",",
"self",
".",
"num_channels",
"]",
")",
"# TODO(msaffar) Add support for non RGB rendered environments",
"frame",
"=",
"png",
".",
"from_array",
"(",
"frame_np",
",",
"\"RGB\"",
",",
"info",
"=",
"{",
"\"bitdepth\"",
":",
"8",
"}",
")",
"frame_buffer",
"=",
"six",
".",
"BytesIO",
"(",
")",
"frame",
".",
"save",
"(",
"frame_buffer",
")",
"# Put the encoded frame back.",
"time_step",
"[",
"_IMAGE_ENCODED_FIELD",
"]",
"=",
"[",
"frame_buffer",
".",
"getvalue",
"(",
")",
"]",
"time_step",
"[",
"_IMAGE_FORMAT_FIELD",
"]",
"=",
"[",
"_FORMAT",
"]",
"time_step",
"[",
"_IMAGE_HEIGHT_FIELD",
"]",
"=",
"[",
"self",
".",
"frame_height",
"]",
"time_step",
"[",
"_IMAGE_WIDTH_FIELD",
"]",
"=",
"[",
"self",
".",
"frame_width",
"]",
"# Add the frame number",
"time_step",
"[",
"_FRAME_NUMBER_FIELD",
"]",
"=",
"time_step",
"[",
"env_problem",
".",
"TIMESTEP_FIELD",
"]",
"yield",
"time_step"
] |
Transforms time step observations to frames of a video.
|
[
"Transforms",
"time",
"step",
"observations",
"to",
"frames",
"of",
"a",
"video",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/envs/rendered_env_problem.py#L87-L108
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
txt_line_iterator
|
def txt_line_iterator(txt_path):
"""Iterate through lines of file."""
with tf.gfile.Open(txt_path) as f:
for line in f:
yield line.strip()
|
python
|
def txt_line_iterator(txt_path):
"""Iterate through lines of file."""
with tf.gfile.Open(txt_path) as f:
for line in f:
yield line.strip()
|
[
"def",
"txt_line_iterator",
"(",
"txt_path",
")",
":",
"with",
"tf",
".",
"gfile",
".",
"Open",
"(",
"txt_path",
")",
"as",
"f",
":",
"for",
"line",
"in",
"f",
":",
"yield",
"line",
".",
"strip",
"(",
")"
] |
Iterate through lines of file.
|
[
"Iterate",
"through",
"lines",
"of",
"file",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L607-L611
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
text2text_txt_iterator
|
def text2text_txt_iterator(source_txt_path, target_txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of files."""
for inputs, targets in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(target_txt_path)):
yield {"inputs": inputs, "targets": targets}
|
python
|
def text2text_txt_iterator(source_txt_path, target_txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of files."""
for inputs, targets in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(target_txt_path)):
yield {"inputs": inputs, "targets": targets}
|
[
"def",
"text2text_txt_iterator",
"(",
"source_txt_path",
",",
"target_txt_path",
")",
":",
"for",
"inputs",
",",
"targets",
"in",
"zip",
"(",
"txt_line_iterator",
"(",
"source_txt_path",
")",
",",
"txt_line_iterator",
"(",
"target_txt_path",
")",
")",
":",
"yield",
"{",
"\"inputs\"",
":",
"inputs",
",",
"\"targets\"",
":",
"targets",
"}"
] |
Yield dicts for Text2TextProblem.generate_samples from lines of files.
|
[
"Yield",
"dicts",
"for",
"Text2TextProblem",
".",
"generate_samples",
"from",
"lines",
"of",
"files",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L614-L618
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
text2text_distill_iterator
|
def text2text_distill_iterator(source_txt_path, target_txt_path,
distill_txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of files."""
for inputs, targets, dist_targets in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(target_txt_path),
txt_line_iterator(distill_txt_path)):
yield {"inputs": inputs, "targets": targets, "dist_targets": dist_targets}
|
python
|
def text2text_distill_iterator(source_txt_path, target_txt_path,
distill_txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of files."""
for inputs, targets, dist_targets in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(target_txt_path),
txt_line_iterator(distill_txt_path)):
yield {"inputs": inputs, "targets": targets, "dist_targets": dist_targets}
|
[
"def",
"text2text_distill_iterator",
"(",
"source_txt_path",
",",
"target_txt_path",
",",
"distill_txt_path",
")",
":",
"for",
"inputs",
",",
"targets",
",",
"dist_targets",
"in",
"zip",
"(",
"txt_line_iterator",
"(",
"source_txt_path",
")",
",",
"txt_line_iterator",
"(",
"target_txt_path",
")",
",",
"txt_line_iterator",
"(",
"distill_txt_path",
")",
")",
":",
"yield",
"{",
"\"inputs\"",
":",
"inputs",
",",
"\"targets\"",
":",
"targets",
",",
"\"dist_targets\"",
":",
"dist_targets",
"}"
] |
Yield dicts for Text2TextProblem.generate_samples from lines of files.
|
[
"Yield",
"dicts",
"for",
"Text2TextProblem",
".",
"generate_samples",
"from",
"lines",
"of",
"files",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L621-L627
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
text2class_txt_iterator
|
def text2class_txt_iterator(source_txt_path, label_txt_path, class_strs=None):
"""Yield dicts for Text2ClassProblem.generate_samples from lines of files.
Args:
source_txt_path: txt file with record per line.
label_txt_path: txt file with label per line, either as int or str. If
string, must provide class_strs.
class_strs: list<str> of class label names. Must be in correct order (i.e.
["a", "b", "c"] means that "a" will get class ID 0, "b" ID 1, etc.).
Yields:
{"inputs": inputs, "label": label}
"""
if class_strs:
class_strs = dict([(s, i) for i, s in enumerate(class_strs)])
for inputs, label in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(label_txt_path)):
label = label.strip()
if class_strs:
label = class_strs[label]
else:
label = int(label)
yield {"inputs": inputs, "label": label}
|
python
|
def text2class_txt_iterator(source_txt_path, label_txt_path, class_strs=None):
"""Yield dicts for Text2ClassProblem.generate_samples from lines of files.
Args:
source_txt_path: txt file with record per line.
label_txt_path: txt file with label per line, either as int or str. If
string, must provide class_strs.
class_strs: list<str> of class label names. Must be in correct order (i.e.
["a", "b", "c"] means that "a" will get class ID 0, "b" ID 1, etc.).
Yields:
{"inputs": inputs, "label": label}
"""
if class_strs:
class_strs = dict([(s, i) for i, s in enumerate(class_strs)])
for inputs, label in zip(
txt_line_iterator(source_txt_path), txt_line_iterator(label_txt_path)):
label = label.strip()
if class_strs:
label = class_strs[label]
else:
label = int(label)
yield {"inputs": inputs, "label": label}
|
[
"def",
"text2class_txt_iterator",
"(",
"source_txt_path",
",",
"label_txt_path",
",",
"class_strs",
"=",
"None",
")",
":",
"if",
"class_strs",
":",
"class_strs",
"=",
"dict",
"(",
"[",
"(",
"s",
",",
"i",
")",
"for",
"i",
",",
"s",
"in",
"enumerate",
"(",
"class_strs",
")",
"]",
")",
"for",
"inputs",
",",
"label",
"in",
"zip",
"(",
"txt_line_iterator",
"(",
"source_txt_path",
")",
",",
"txt_line_iterator",
"(",
"label_txt_path",
")",
")",
":",
"label",
"=",
"label",
".",
"strip",
"(",
")",
"if",
"class_strs",
":",
"label",
"=",
"class_strs",
"[",
"label",
"]",
"else",
":",
"label",
"=",
"int",
"(",
"label",
")",
"yield",
"{",
"\"inputs\"",
":",
"inputs",
",",
"\"label\"",
":",
"label",
"}"
] |
Yield dicts for Text2ClassProblem.generate_samples from lines of files.
Args:
source_txt_path: txt file with record per line.
label_txt_path: txt file with label per line, either as int or str. If
string, must provide class_strs.
class_strs: list<str> of class label names. Must be in correct order (i.e.
["a", "b", "c"] means that "a" will get class ID 0, "b" ID 1, etc.).
Yields:
{"inputs": inputs, "label": label}
|
[
"Yield",
"dicts",
"for",
"Text2ClassProblem",
".",
"generate_samples",
"from",
"lines",
"of",
"files",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L635-L657
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
text2text_txt_tab_iterator
|
def text2text_txt_tab_iterator(txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of txt_path.
Args:
txt_path: path to txt file with a record per line, source and target
are tab-separated.
Yields:
{"inputs": inputs, "targets": targets}
"""
for line in txt_line_iterator(txt_path):
if line and "\t" in line:
parts = line.split("\t", 1)
inputs, targets = parts[:2]
yield {"inputs": inputs.strip(), "targets": targets.strip()}
|
python
|
def text2text_txt_tab_iterator(txt_path):
"""Yield dicts for Text2TextProblem.generate_samples from lines of txt_path.
Args:
txt_path: path to txt file with a record per line, source and target
are tab-separated.
Yields:
{"inputs": inputs, "targets": targets}
"""
for line in txt_line_iterator(txt_path):
if line and "\t" in line:
parts = line.split("\t", 1)
inputs, targets = parts[:2]
yield {"inputs": inputs.strip(), "targets": targets.strip()}
|
[
"def",
"text2text_txt_tab_iterator",
"(",
"txt_path",
")",
":",
"for",
"line",
"in",
"txt_line_iterator",
"(",
"txt_path",
")",
":",
"if",
"line",
"and",
"\"\\t\"",
"in",
"line",
":",
"parts",
"=",
"line",
".",
"split",
"(",
"\"\\t\"",
",",
"1",
")",
"inputs",
",",
"targets",
"=",
"parts",
"[",
":",
"2",
"]",
"yield",
"{",
"\"inputs\"",
":",
"inputs",
".",
"strip",
"(",
")",
",",
"\"targets\"",
":",
"targets",
".",
"strip",
"(",
")",
"}"
] |
Yield dicts for Text2TextProblem.generate_samples from lines of txt_path.
Args:
txt_path: path to txt file with a record per line, source and target
are tab-separated.
Yields:
{"inputs": inputs, "targets": targets}
|
[
"Yield",
"dicts",
"for",
"Text2TextProblem",
".",
"generate_samples",
"from",
"lines",
"of",
"txt_path",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L660-L674
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
text2text_generate_encoded
|
def text2text_generate_encoded(sample_generator,
vocab,
targets_vocab=None,
has_inputs=True,
inputs_prefix="",
targets_prefix=""):
"""Encode Text2Text samples from the generator with the vocab."""
targets_vocab = targets_vocab or vocab
for sample in sample_generator:
if has_inputs:
sample["inputs"] = vocab.encode(inputs_prefix + sample["inputs"])
sample["inputs"].append(text_encoder.EOS_ID)
sample["targets"] = targets_vocab.encode(targets_prefix + sample["targets"])
sample["targets"].append(text_encoder.EOS_ID)
yield sample
|
python
|
def text2text_generate_encoded(sample_generator,
vocab,
targets_vocab=None,
has_inputs=True,
inputs_prefix="",
targets_prefix=""):
"""Encode Text2Text samples from the generator with the vocab."""
targets_vocab = targets_vocab or vocab
for sample in sample_generator:
if has_inputs:
sample["inputs"] = vocab.encode(inputs_prefix + sample["inputs"])
sample["inputs"].append(text_encoder.EOS_ID)
sample["targets"] = targets_vocab.encode(targets_prefix + sample["targets"])
sample["targets"].append(text_encoder.EOS_ID)
yield sample
|
[
"def",
"text2text_generate_encoded",
"(",
"sample_generator",
",",
"vocab",
",",
"targets_vocab",
"=",
"None",
",",
"has_inputs",
"=",
"True",
",",
"inputs_prefix",
"=",
"\"\"",
",",
"targets_prefix",
"=",
"\"\"",
")",
":",
"targets_vocab",
"=",
"targets_vocab",
"or",
"vocab",
"for",
"sample",
"in",
"sample_generator",
":",
"if",
"has_inputs",
":",
"sample",
"[",
"\"inputs\"",
"]",
"=",
"vocab",
".",
"encode",
"(",
"inputs_prefix",
"+",
"sample",
"[",
"\"inputs\"",
"]",
")",
"sample",
"[",
"\"inputs\"",
"]",
".",
"append",
"(",
"text_encoder",
".",
"EOS_ID",
")",
"sample",
"[",
"\"targets\"",
"]",
"=",
"targets_vocab",
".",
"encode",
"(",
"targets_prefix",
"+",
"sample",
"[",
"\"targets\"",
"]",
")",
"sample",
"[",
"\"targets\"",
"]",
".",
"append",
"(",
"text_encoder",
".",
"EOS_ID",
")",
"yield",
"sample"
] |
Encode Text2Text samples from the generator with the vocab.
|
[
"Encode",
"Text2Text",
"samples",
"from",
"the",
"generator",
"with",
"the",
"vocab",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L677-L691
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
Text2TextProblem._pack_fn
|
def _pack_fn(self):
"""For packed datasets, returns a function to pack examples.
Returns:
None or a function from list of TFRecords to list of TFRecords
"""
if not self.packed_length:
return None
def my_fn(records):
"""Function from list of TFRecords to list of TFRecords."""
examples = []
for record in records:
x = tf.train.Example()
x.ParseFromString(record)
example_dict = {}
if self.has_inputs:
example_dict["inputs"] = [
int(i) for i in x.features.feature["inputs"].int64_list.value]
example_dict["targets"] = [
int(i) for i in x.features.feature["targets"].int64_list.value]
examples.append(example_dict)
examples = list(self._maybe_pack_examples(examples))
return [
generator_utils.to_example(x).SerializeToString() for x in examples]
return my_fn
|
python
|
def _pack_fn(self):
"""For packed datasets, returns a function to pack examples.
Returns:
None or a function from list of TFRecords to list of TFRecords
"""
if not self.packed_length:
return None
def my_fn(records):
"""Function from list of TFRecords to list of TFRecords."""
examples = []
for record in records:
x = tf.train.Example()
x.ParseFromString(record)
example_dict = {}
if self.has_inputs:
example_dict["inputs"] = [
int(i) for i in x.features.feature["inputs"].int64_list.value]
example_dict["targets"] = [
int(i) for i in x.features.feature["targets"].int64_list.value]
examples.append(example_dict)
examples = list(self._maybe_pack_examples(examples))
return [
generator_utils.to_example(x).SerializeToString() for x in examples]
return my_fn
|
[
"def",
"_pack_fn",
"(",
"self",
")",
":",
"if",
"not",
"self",
".",
"packed_length",
":",
"return",
"None",
"def",
"my_fn",
"(",
"records",
")",
":",
"\"\"\"Function from list of TFRecords to list of TFRecords.\"\"\"",
"examples",
"=",
"[",
"]",
"for",
"record",
"in",
"records",
":",
"x",
"=",
"tf",
".",
"train",
".",
"Example",
"(",
")",
"x",
".",
"ParseFromString",
"(",
"record",
")",
"example_dict",
"=",
"{",
"}",
"if",
"self",
".",
"has_inputs",
":",
"example_dict",
"[",
"\"inputs\"",
"]",
"=",
"[",
"int",
"(",
"i",
")",
"for",
"i",
"in",
"x",
".",
"features",
".",
"feature",
"[",
"\"inputs\"",
"]",
".",
"int64_list",
".",
"value",
"]",
"example_dict",
"[",
"\"targets\"",
"]",
"=",
"[",
"int",
"(",
"i",
")",
"for",
"i",
"in",
"x",
".",
"features",
".",
"feature",
"[",
"\"targets\"",
"]",
".",
"int64_list",
".",
"value",
"]",
"examples",
".",
"append",
"(",
"example_dict",
")",
"examples",
"=",
"list",
"(",
"self",
".",
"_maybe_pack_examples",
"(",
"examples",
")",
")",
"return",
"[",
"generator_utils",
".",
"to_example",
"(",
"x",
")",
".",
"SerializeToString",
"(",
")",
"for",
"x",
"in",
"examples",
"]",
"return",
"my_fn"
] |
For packed datasets, returns a function to pack examples.
Returns:
None or a function from list of TFRecords to list of TFRecords
|
[
"For",
"packed",
"datasets",
"returns",
"a",
"function",
"to",
"pack",
"examples",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L263-L287
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
Text2TextProblem._maybe_pack_examples
|
def _maybe_pack_examples(self, generator):
"""Wraps generator with packer if self.packed_length."""
if not self.packed_length:
return generator
return generator_utils.pack_examples(
generator,
self.has_inputs,
self.packed_length,
spacing=self.packed_spacing,
chop_long_sequences=not self.has_inputs)
|
python
|
def _maybe_pack_examples(self, generator):
"""Wraps generator with packer if self.packed_length."""
if not self.packed_length:
return generator
return generator_utils.pack_examples(
generator,
self.has_inputs,
self.packed_length,
spacing=self.packed_spacing,
chop_long_sequences=not self.has_inputs)
|
[
"def",
"_maybe_pack_examples",
"(",
"self",
",",
"generator",
")",
":",
"if",
"not",
"self",
".",
"packed_length",
":",
"return",
"generator",
"return",
"generator_utils",
".",
"pack_examples",
"(",
"generator",
",",
"self",
".",
"has_inputs",
",",
"self",
".",
"packed_length",
",",
"spacing",
"=",
"self",
".",
"packed_spacing",
",",
"chop_long_sequences",
"=",
"not",
"self",
".",
"has_inputs",
")"
] |
Wraps generator with packer if self.packed_length.
|
[
"Wraps",
"generator",
"with",
"packer",
"if",
"self",
".",
"packed_length",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L289-L298
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.text_filepaths_for_task
|
def text_filepaths_for_task(self, tmp_dir, task_id):
"""List of input filepaths for a particular training or dev shard.
Args:
tmp_dir: a string
task_id: an integer less than self.num_shards
Returns:
a list of tuples (filepath, start_pos, num_bytes)
"""
assert task_id >= 0
assert task_id < self.num_train_shards + self.num_dev_shards
if task_id < self.num_train_shards:
return [
f for i, f in enumerate(self.train_text_filepaths(tmp_dir))
if i % self.num_train_shards == task_id
]
else:
return [
f for i, f in enumerate(self.dev_text_filepaths(tmp_dir))
if i % self.num_dev_shards == task_id - self.num_train_shards
]
|
python
|
def text_filepaths_for_task(self, tmp_dir, task_id):
"""List of input filepaths for a particular training or dev shard.
Args:
tmp_dir: a string
task_id: an integer less than self.num_shards
Returns:
a list of tuples (filepath, start_pos, num_bytes)
"""
assert task_id >= 0
assert task_id < self.num_train_shards + self.num_dev_shards
if task_id < self.num_train_shards:
return [
f for i, f in enumerate(self.train_text_filepaths(tmp_dir))
if i % self.num_train_shards == task_id
]
else:
return [
f for i, f in enumerate(self.dev_text_filepaths(tmp_dir))
if i % self.num_dev_shards == task_id - self.num_train_shards
]
|
[
"def",
"text_filepaths_for_task",
"(",
"self",
",",
"tmp_dir",
",",
"task_id",
")",
":",
"assert",
"task_id",
">=",
"0",
"assert",
"task_id",
"<",
"self",
".",
"num_train_shards",
"+",
"self",
".",
"num_dev_shards",
"if",
"task_id",
"<",
"self",
".",
"num_train_shards",
":",
"return",
"[",
"f",
"for",
"i",
",",
"f",
"in",
"enumerate",
"(",
"self",
".",
"train_text_filepaths",
"(",
"tmp_dir",
")",
")",
"if",
"i",
"%",
"self",
".",
"num_train_shards",
"==",
"task_id",
"]",
"else",
":",
"return",
"[",
"f",
"for",
"i",
",",
"f",
"in",
"enumerate",
"(",
"self",
".",
"dev_text_filepaths",
"(",
"tmp_dir",
")",
")",
"if",
"i",
"%",
"self",
".",
"num_dev_shards",
"==",
"task_id",
"-",
"self",
".",
"num_train_shards",
"]"
] |
List of input filepaths for a particular training or dev shard.
Args:
tmp_dir: a string
task_id: an integer less than self.num_shards
Returns:
a list of tuples (filepath, start_pos, num_bytes)
|
[
"List",
"of",
"input",
"filepaths",
"for",
"a",
"particular",
"training",
"or",
"dev",
"shard",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L831-L851
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.filepath_to_unicode_strings
|
def filepath_to_unicode_strings(self, filepath):
"""Read text out of an input file.
The default just reads the text, converts to unicode and yields one
unicode string.
Subclasses can override this function in order to preprocess, and can
yield any number of strings.
Args:
filepath: a string
Yields:
unicode strings.
"""
f = tf.gfile.Open(filepath)
b = f.read()
yield text_encoder.to_unicode_ignore_errors(b)
|
python
|
def filepath_to_unicode_strings(self, filepath):
"""Read text out of an input file.
The default just reads the text, converts to unicode and yields one
unicode string.
Subclasses can override this function in order to preprocess, and can
yield any number of strings.
Args:
filepath: a string
Yields:
unicode strings.
"""
f = tf.gfile.Open(filepath)
b = f.read()
yield text_encoder.to_unicode_ignore_errors(b)
|
[
"def",
"filepath_to_unicode_strings",
"(",
"self",
",",
"filepath",
")",
":",
"f",
"=",
"tf",
".",
"gfile",
".",
"Open",
"(",
"filepath",
")",
"b",
"=",
"f",
".",
"read",
"(",
")",
"yield",
"text_encoder",
".",
"to_unicode_ignore_errors",
"(",
"b",
")"
] |
Read text out of an input file.
The default just reads the text, converts to unicode and yields one
unicode string.
Subclasses can override this function in order to preprocess, and can
yield any number of strings.
Args:
filepath: a string
Yields:
unicode strings.
|
[
"Read",
"text",
"out",
"of",
"an",
"input",
"file",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L853-L869
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.file_generator
|
def file_generator(self,
filepaths,
max_chars_per_file=None,
max_chars_total=None):
"""Read complete text of input files and yield unicode strings.
By default, one unicode string is produced per file, but this is
not guaranteed, since subclasses can override
filepath_to_unicode_strings().
max_chars_per_file and max_chars_total can also be specified, in which
case some strings may be truncated or dropped to limit the total
amount of output.
Args:
filepaths: a list of strings
max_chars_per_file: an optional integer
max_chars_total: an optional integer
Yields:
unicode strings
"""
chars_total = 0
for fname in filepaths:
chars_this_file = 0
tf.logging.info("reading file %s" % fname)
for text in self.filepath_to_unicode_strings(fname):
if (max_chars_per_file and
chars_this_file + len(text) > max_chars_per_file):
text = text[:max_chars_per_file - chars_this_file]
if max_chars_total and chars_total + len(text) > max_chars_total:
text = text[:max_chars_total - chars_total]
chars_total += len(text)
chars_this_file += len(text)
if text:
yield text
if max_chars_total and chars_total >= max_chars_total:
return
if max_chars_per_file and chars_this_file >= max_chars_per_file:
break
|
python
|
def file_generator(self,
filepaths,
max_chars_per_file=None,
max_chars_total=None):
"""Read complete text of input files and yield unicode strings.
By default, one unicode string is produced per file, but this is
not guaranteed, since subclasses can override
filepath_to_unicode_strings().
max_chars_per_file and max_chars_total can also be specified, in which
case some strings may be truncated or dropped to limit the total
amount of output.
Args:
filepaths: a list of strings
max_chars_per_file: an optional integer
max_chars_total: an optional integer
Yields:
unicode strings
"""
chars_total = 0
for fname in filepaths:
chars_this_file = 0
tf.logging.info("reading file %s" % fname)
for text in self.filepath_to_unicode_strings(fname):
if (max_chars_per_file and
chars_this_file + len(text) > max_chars_per_file):
text = text[:max_chars_per_file - chars_this_file]
if max_chars_total and chars_total + len(text) > max_chars_total:
text = text[:max_chars_total - chars_total]
chars_total += len(text)
chars_this_file += len(text)
if text:
yield text
if max_chars_total and chars_total >= max_chars_total:
return
if max_chars_per_file and chars_this_file >= max_chars_per_file:
break
|
[
"def",
"file_generator",
"(",
"self",
",",
"filepaths",
",",
"max_chars_per_file",
"=",
"None",
",",
"max_chars_total",
"=",
"None",
")",
":",
"chars_total",
"=",
"0",
"for",
"fname",
"in",
"filepaths",
":",
"chars_this_file",
"=",
"0",
"tf",
".",
"logging",
".",
"info",
"(",
"\"reading file %s\"",
"%",
"fname",
")",
"for",
"text",
"in",
"self",
".",
"filepath_to_unicode_strings",
"(",
"fname",
")",
":",
"if",
"(",
"max_chars_per_file",
"and",
"chars_this_file",
"+",
"len",
"(",
"text",
")",
">",
"max_chars_per_file",
")",
":",
"text",
"=",
"text",
"[",
":",
"max_chars_per_file",
"-",
"chars_this_file",
"]",
"if",
"max_chars_total",
"and",
"chars_total",
"+",
"len",
"(",
"text",
")",
">",
"max_chars_total",
":",
"text",
"=",
"text",
"[",
":",
"max_chars_total",
"-",
"chars_total",
"]",
"chars_total",
"+=",
"len",
"(",
"text",
")",
"chars_this_file",
"+=",
"len",
"(",
"text",
")",
"if",
"text",
":",
"yield",
"text",
"if",
"max_chars_total",
"and",
"chars_total",
">=",
"max_chars_total",
":",
"return",
"if",
"max_chars_per_file",
"and",
"chars_this_file",
">=",
"max_chars_per_file",
":",
"break"
] |
Read complete text of input files and yield unicode strings.
By default, one unicode string is produced per file, but this is
not guaranteed, since subclasses can override
filepath_to_unicode_strings().
max_chars_per_file and max_chars_total can also be specified, in which
case some strings may be truncated or dropped to limit the total
amount of output.
Args:
filepaths: a list of strings
max_chars_per_file: an optional integer
max_chars_total: an optional integer
Yields:
unicode strings
|
[
"Read",
"complete",
"text",
"of",
"input",
"files",
"and",
"yield",
"unicode",
"strings",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L871-L909
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.example_generator
|
def example_generator(self, encoder, tmp_dir, task_id):
"""Generator for examples.
Args:
encoder: a TextEncoder
tmp_dir: a string
task_id: an integer
Yields:
feature dictionaries
"""
filepaths = self.text_filepaths_for_task(tmp_dir, task_id)
if task_id >= self.num_train_shards:
# this is dev data - limit the total length.
max_chars_per_file = self.max_dev_chars // (
self.num_dev_shards * len(filepaths))
else:
max_chars_per_file = None
tokens = []
for ftext in self.file_generator(
filepaths, max_chars_per_file=max_chars_per_file):
tokens.extend(encoder.encode(ftext))
pos = 0
while pos + self.sequence_length <= len(tokens):
yield {"targets": tokens[pos:pos + self.sequence_length]}
pos += self.sequence_length
if pos > 0:
tokens = tokens[pos:]
if self.remainder_policy == "pad":
if tokens:
targets = tokens + [0] * (self.sequence_length - len(tokens))
yield {"targets": targets}
else:
assert self.remainder_policy == "drop"
|
python
|
def example_generator(self, encoder, tmp_dir, task_id):
"""Generator for examples.
Args:
encoder: a TextEncoder
tmp_dir: a string
task_id: an integer
Yields:
feature dictionaries
"""
filepaths = self.text_filepaths_for_task(tmp_dir, task_id)
if task_id >= self.num_train_shards:
# this is dev data - limit the total length.
max_chars_per_file = self.max_dev_chars // (
self.num_dev_shards * len(filepaths))
else:
max_chars_per_file = None
tokens = []
for ftext in self.file_generator(
filepaths, max_chars_per_file=max_chars_per_file):
tokens.extend(encoder.encode(ftext))
pos = 0
while pos + self.sequence_length <= len(tokens):
yield {"targets": tokens[pos:pos + self.sequence_length]}
pos += self.sequence_length
if pos > 0:
tokens = tokens[pos:]
if self.remainder_policy == "pad":
if tokens:
targets = tokens + [0] * (self.sequence_length - len(tokens))
yield {"targets": targets}
else:
assert self.remainder_policy == "drop"
|
[
"def",
"example_generator",
"(",
"self",
",",
"encoder",
",",
"tmp_dir",
",",
"task_id",
")",
":",
"filepaths",
"=",
"self",
".",
"text_filepaths_for_task",
"(",
"tmp_dir",
",",
"task_id",
")",
"if",
"task_id",
">=",
"self",
".",
"num_train_shards",
":",
"# this is dev data - limit the total length.",
"max_chars_per_file",
"=",
"self",
".",
"max_dev_chars",
"//",
"(",
"self",
".",
"num_dev_shards",
"*",
"len",
"(",
"filepaths",
")",
")",
"else",
":",
"max_chars_per_file",
"=",
"None",
"tokens",
"=",
"[",
"]",
"for",
"ftext",
"in",
"self",
".",
"file_generator",
"(",
"filepaths",
",",
"max_chars_per_file",
"=",
"max_chars_per_file",
")",
":",
"tokens",
".",
"extend",
"(",
"encoder",
".",
"encode",
"(",
"ftext",
")",
")",
"pos",
"=",
"0",
"while",
"pos",
"+",
"self",
".",
"sequence_length",
"<=",
"len",
"(",
"tokens",
")",
":",
"yield",
"{",
"\"targets\"",
":",
"tokens",
"[",
"pos",
":",
"pos",
"+",
"self",
".",
"sequence_length",
"]",
"}",
"pos",
"+=",
"self",
".",
"sequence_length",
"if",
"pos",
">",
"0",
":",
"tokens",
"=",
"tokens",
"[",
"pos",
":",
"]",
"if",
"self",
".",
"remainder_policy",
"==",
"\"pad\"",
":",
"if",
"tokens",
":",
"targets",
"=",
"tokens",
"+",
"[",
"0",
"]",
"*",
"(",
"self",
".",
"sequence_length",
"-",
"len",
"(",
"tokens",
")",
")",
"yield",
"{",
"\"targets\"",
":",
"targets",
"}",
"else",
":",
"assert",
"self",
".",
"remainder_policy",
"==",
"\"drop\""
] |
Generator for examples.
Args:
encoder: a TextEncoder
tmp_dir: a string
task_id: an integer
Yields:
feature dictionaries
|
[
"Generator",
"for",
"examples",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L911-L943
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.prepare_to_generate
|
def prepare_to_generate(self, data_dir, tmp_dir):
"""Make sure that the data is prepared and the vocab is generated."""
self.get_or_create_vocab(data_dir, tmp_dir)
self.train_text_filepaths(tmp_dir)
self.dev_text_filepaths(tmp_dir)
|
python
|
def prepare_to_generate(self, data_dir, tmp_dir):
"""Make sure that the data is prepared and the vocab is generated."""
self.get_or_create_vocab(data_dir, tmp_dir)
self.train_text_filepaths(tmp_dir)
self.dev_text_filepaths(tmp_dir)
|
[
"def",
"prepare_to_generate",
"(",
"self",
",",
"data_dir",
",",
"tmp_dir",
")",
":",
"self",
".",
"get_or_create_vocab",
"(",
"data_dir",
",",
"tmp_dir",
")",
"self",
".",
"train_text_filepaths",
"(",
"tmp_dir",
")",
"self",
".",
"dev_text_filepaths",
"(",
"tmp_dir",
")"
] |
Make sure that the data is prepared and the vocab is generated.
|
[
"Make",
"sure",
"that",
"the",
"data",
"is",
"prepared",
"and",
"the",
"vocab",
"is",
"generated",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L954-L958
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/text_problems.py
|
ChoppedTextProblem.generate_data
|
def generate_data(self, data_dir, tmp_dir, task_id=-1):
"""Generates training/dev data.
Args:
data_dir: a string
tmp_dir: a string
task_id: an optional integer
Returns:
shard or shards for which data was generated.
"""
tf.logging.info("generate_data task_id=%s" % task_id)
encoder = self.get_or_create_vocab(data_dir, tmp_dir)
assert task_id >= 0 and task_id < self.num_generate_tasks
if task_id < self.num_train_shards:
out_file = self.training_filepaths(
data_dir, self.num_train_shards, shuffled=False)[task_id]
else:
out_file = self.dev_filepaths(
data_dir, self.num_dev_shards,
shuffled=False)[task_id - self.num_train_shards]
generator_utils.generate_files(
self.example_generator(encoder, tmp_dir, task_id), [out_file])
generator_utils.shuffle_dataset([out_file])
|
python
|
def generate_data(self, data_dir, tmp_dir, task_id=-1):
"""Generates training/dev data.
Args:
data_dir: a string
tmp_dir: a string
task_id: an optional integer
Returns:
shard or shards for which data was generated.
"""
tf.logging.info("generate_data task_id=%s" % task_id)
encoder = self.get_or_create_vocab(data_dir, tmp_dir)
assert task_id >= 0 and task_id < self.num_generate_tasks
if task_id < self.num_train_shards:
out_file = self.training_filepaths(
data_dir, self.num_train_shards, shuffled=False)[task_id]
else:
out_file = self.dev_filepaths(
data_dir, self.num_dev_shards,
shuffled=False)[task_id - self.num_train_shards]
generator_utils.generate_files(
self.example_generator(encoder, tmp_dir, task_id), [out_file])
generator_utils.shuffle_dataset([out_file])
|
[
"def",
"generate_data",
"(",
"self",
",",
"data_dir",
",",
"tmp_dir",
",",
"task_id",
"=",
"-",
"1",
")",
":",
"tf",
".",
"logging",
".",
"info",
"(",
"\"generate_data task_id=%s\"",
"%",
"task_id",
")",
"encoder",
"=",
"self",
".",
"get_or_create_vocab",
"(",
"data_dir",
",",
"tmp_dir",
")",
"assert",
"task_id",
">=",
"0",
"and",
"task_id",
"<",
"self",
".",
"num_generate_tasks",
"if",
"task_id",
"<",
"self",
".",
"num_train_shards",
":",
"out_file",
"=",
"self",
".",
"training_filepaths",
"(",
"data_dir",
",",
"self",
".",
"num_train_shards",
",",
"shuffled",
"=",
"False",
")",
"[",
"task_id",
"]",
"else",
":",
"out_file",
"=",
"self",
".",
"dev_filepaths",
"(",
"data_dir",
",",
"self",
".",
"num_dev_shards",
",",
"shuffled",
"=",
"False",
")",
"[",
"task_id",
"-",
"self",
".",
"num_train_shards",
"]",
"generator_utils",
".",
"generate_files",
"(",
"self",
".",
"example_generator",
"(",
"encoder",
",",
"tmp_dir",
",",
"task_id",
")",
",",
"[",
"out_file",
"]",
")",
"generator_utils",
".",
"shuffle_dataset",
"(",
"[",
"out_file",
"]",
")"
] |
Generates training/dev data.
Args:
data_dir: a string
tmp_dir: a string
task_id: an optional integer
Returns:
shard or shards for which data was generated.
|
[
"Generates",
"training",
"/",
"dev",
"data",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/text_problems.py#L965-L987
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/models/resnet.py
|
ConvBlock
|
def ConvBlock(kernel_size, filters, strides):
"""ResNet convolutional striding block."""
ks = kernel_size
filters1, filters2, filters3 = filters
main = layers.Serial(
layers.Conv(filters1, (1, 1), strides),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters2, (ks, ks), padding='SAME'),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters3, (1, 1)),
layers.BatchNorm()
)
shortcut = layers.Serial(
layers.Conv(filters3, (1, 1), strides),
layers.BatchNorm()
)
return layers.Serial(
layers.Branch(),
layers.Parallel(main, shortcut),
layers.SumBranches(),
layers.Relu()
)
|
python
|
def ConvBlock(kernel_size, filters, strides):
"""ResNet convolutional striding block."""
ks = kernel_size
filters1, filters2, filters3 = filters
main = layers.Serial(
layers.Conv(filters1, (1, 1), strides),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters2, (ks, ks), padding='SAME'),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters3, (1, 1)),
layers.BatchNorm()
)
shortcut = layers.Serial(
layers.Conv(filters3, (1, 1), strides),
layers.BatchNorm()
)
return layers.Serial(
layers.Branch(),
layers.Parallel(main, shortcut),
layers.SumBranches(),
layers.Relu()
)
|
[
"def",
"ConvBlock",
"(",
"kernel_size",
",",
"filters",
",",
"strides",
")",
":",
"ks",
"=",
"kernel_size",
"filters1",
",",
"filters2",
",",
"filters3",
"=",
"filters",
"main",
"=",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Conv",
"(",
"filters1",
",",
"(",
"1",
",",
"1",
")",
",",
"strides",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"filters2",
",",
"(",
"ks",
",",
"ks",
")",
",",
"padding",
"=",
"'SAME'",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"filters3",
",",
"(",
"1",
",",
"1",
")",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
")",
"shortcut",
"=",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Conv",
"(",
"filters3",
",",
"(",
"1",
",",
"1",
")",
",",
"strides",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
")",
"return",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Branch",
"(",
")",
",",
"layers",
".",
"Parallel",
"(",
"main",
",",
"shortcut",
")",
",",
"layers",
".",
"SumBranches",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
")"
] |
ResNet convolutional striding block.
|
[
"ResNet",
"convolutional",
"striding",
"block",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/models/resnet.py#L25-L48
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/models/resnet.py
|
IdentityBlock
|
def IdentityBlock(kernel_size, filters):
"""ResNet identical size block."""
ks = kernel_size
filters1, filters2, filters3 = filters
main = layers.Serial(
layers.Conv(filters1, (1, 1)),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters2, (ks, ks), padding='SAME'),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters3, (1, 1)),
layers.BatchNorm()
)
return layers.Serial(
layers.Branch(),
layers.Parallel(main, layers.Identity()),
layers.SumBranches(),
layers.Relu()
)
|
python
|
def IdentityBlock(kernel_size, filters):
"""ResNet identical size block."""
ks = kernel_size
filters1, filters2, filters3 = filters
main = layers.Serial(
layers.Conv(filters1, (1, 1)),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters2, (ks, ks), padding='SAME'),
layers.BatchNorm(),
layers.Relu(),
layers.Conv(filters3, (1, 1)),
layers.BatchNorm()
)
return layers.Serial(
layers.Branch(),
layers.Parallel(main, layers.Identity()),
layers.SumBranches(),
layers.Relu()
)
|
[
"def",
"IdentityBlock",
"(",
"kernel_size",
",",
"filters",
")",
":",
"ks",
"=",
"kernel_size",
"filters1",
",",
"filters2",
",",
"filters3",
"=",
"filters",
"main",
"=",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Conv",
"(",
"filters1",
",",
"(",
"1",
",",
"1",
")",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"filters2",
",",
"(",
"ks",
",",
"ks",
")",
",",
"padding",
"=",
"'SAME'",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"filters3",
",",
"(",
"1",
",",
"1",
")",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
")",
"return",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Branch",
"(",
")",
",",
"layers",
".",
"Parallel",
"(",
"main",
",",
"layers",
".",
"Identity",
"(",
")",
")",
",",
"layers",
".",
"SumBranches",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
")"
] |
ResNet identical size block.
|
[
"ResNet",
"identical",
"size",
"block",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/models/resnet.py#L51-L70
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/models/resnet.py
|
Resnet50
|
def Resnet50(hidden_size=64, num_output_classes=1001, mode='train'):
"""ResNet.
Args:
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: how many classes to distinguish.
mode: whether we are training or evaluating or doing inference.
Returns:
The ResNet model with the given layer and output sizes.
"""
del mode
return layers.Serial(
layers.Conv(hidden_size, (7, 7), (2, 2), 'SAME'),
layers.BatchNorm(), layers.Relu(),
layers.MaxPool(pool_size=(3, 3), strides=(2, 2)),
ConvBlock(3, [hidden_size, hidden_size, 4 * hidden_size], (1, 1)),
IdentityBlock(3, [hidden_size, hidden_size, 4 * hidden_size]),
IdentityBlock(3, [hidden_size, hidden_size, 4 * hidden_size]),
ConvBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size], (2, 2)),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
ConvBlock(3, [4 * hidden_size, 4 * hidden_size, 16*hidden_size], (2, 2)),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
ConvBlock(3, [8 * hidden_size, 8 * hidden_size, 32*hidden_size], (2, 2)),
IdentityBlock(3, [8 * hidden_size, 8 * hidden_size, 32 * hidden_size]),
IdentityBlock(3, [8 * hidden_size, 8 * hidden_size, 32 * hidden_size]),
layers.AvgPool(pool_size=(7, 7)), layers.Flatten(),
layers.Dense(num_output_classes), layers.LogSoftmax())
|
python
|
def Resnet50(hidden_size=64, num_output_classes=1001, mode='train'):
"""ResNet.
Args:
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: how many classes to distinguish.
mode: whether we are training or evaluating or doing inference.
Returns:
The ResNet model with the given layer and output sizes.
"""
del mode
return layers.Serial(
layers.Conv(hidden_size, (7, 7), (2, 2), 'SAME'),
layers.BatchNorm(), layers.Relu(),
layers.MaxPool(pool_size=(3, 3), strides=(2, 2)),
ConvBlock(3, [hidden_size, hidden_size, 4 * hidden_size], (1, 1)),
IdentityBlock(3, [hidden_size, hidden_size, 4 * hidden_size]),
IdentityBlock(3, [hidden_size, hidden_size, 4 * hidden_size]),
ConvBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size], (2, 2)),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
IdentityBlock(3, [2 * hidden_size, 2 * hidden_size, 8 * hidden_size]),
ConvBlock(3, [4 * hidden_size, 4 * hidden_size, 16*hidden_size], (2, 2)),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
IdentityBlock(3, [4 * hidden_size, 4 * hidden_size, 16 * hidden_size]),
ConvBlock(3, [8 * hidden_size, 8 * hidden_size, 32*hidden_size], (2, 2)),
IdentityBlock(3, [8 * hidden_size, 8 * hidden_size, 32 * hidden_size]),
IdentityBlock(3, [8 * hidden_size, 8 * hidden_size, 32 * hidden_size]),
layers.AvgPool(pool_size=(7, 7)), layers.Flatten(),
layers.Dense(num_output_classes), layers.LogSoftmax())
|
[
"def",
"Resnet50",
"(",
"hidden_size",
"=",
"64",
",",
"num_output_classes",
"=",
"1001",
",",
"mode",
"=",
"'train'",
")",
":",
"del",
"mode",
"return",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Conv",
"(",
"hidden_size",
",",
"(",
"7",
",",
"7",
")",
",",
"(",
"2",
",",
"2",
")",
",",
"'SAME'",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"MaxPool",
"(",
"pool_size",
"=",
"(",
"3",
",",
"3",
")",
",",
"strides",
"=",
"(",
"2",
",",
"2",
")",
")",
",",
"ConvBlock",
"(",
"3",
",",
"[",
"hidden_size",
",",
"hidden_size",
",",
"4",
"*",
"hidden_size",
"]",
",",
"(",
"1",
",",
"1",
")",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"hidden_size",
",",
"hidden_size",
",",
"4",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"hidden_size",
",",
"hidden_size",
",",
"4",
"*",
"hidden_size",
"]",
")",
",",
"ConvBlock",
"(",
"3",
",",
"[",
"2",
"*",
"hidden_size",
",",
"2",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
"]",
",",
"(",
"2",
",",
"2",
")",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"2",
"*",
"hidden_size",
",",
"2",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"2",
"*",
"hidden_size",
",",
"2",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"2",
"*",
"hidden_size",
",",
"2",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
"]",
")",
",",
"ConvBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
",",
"(",
"2",
",",
"2",
")",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"4",
"*",
"hidden_size",
",",
"4",
"*",
"hidden_size",
",",
"16",
"*",
"hidden_size",
"]",
")",
",",
"ConvBlock",
"(",
"3",
",",
"[",
"8",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
",",
"32",
"*",
"hidden_size",
"]",
",",
"(",
"2",
",",
"2",
")",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"8",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
",",
"32",
"*",
"hidden_size",
"]",
")",
",",
"IdentityBlock",
"(",
"3",
",",
"[",
"8",
"*",
"hidden_size",
",",
"8",
"*",
"hidden_size",
",",
"32",
"*",
"hidden_size",
"]",
")",
",",
"layers",
".",
"AvgPool",
"(",
"pool_size",
"=",
"(",
"7",
",",
"7",
")",
")",
",",
"layers",
".",
"Flatten",
"(",
")",
",",
"layers",
".",
"Dense",
"(",
"num_output_classes",
")",
",",
"layers",
".",
"LogSoftmax",
"(",
")",
")"
] |
ResNet.
Args:
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: how many classes to distinguish.
mode: whether we are training or evaluating or doing inference.
Returns:
The ResNet model with the given layer and output sizes.
|
[
"ResNet",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/models/resnet.py#L73-L106
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/models/resnet.py
|
WideResnetBlock
|
def WideResnetBlock(channels, strides=(1, 1), channel_mismatch=False):
"""WideResnet convolutational block."""
main = layers.Serial(layers.BatchNorm(), layers.Relu(),
layers.Conv(channels, (3, 3), strides, padding='SAME'),
layers.BatchNorm(), layers.Relu(),
layers.Conv(channels, (3, 3), padding='SAME'))
shortcut = layers.Identity() if not channel_mismatch else layers.Conv(
channels, (3, 3), strides, padding='SAME')
return layers.Serial(
layers.Branch(), layers.Parallel(main, shortcut), layers.SumBranches())
|
python
|
def WideResnetBlock(channels, strides=(1, 1), channel_mismatch=False):
"""WideResnet convolutational block."""
main = layers.Serial(layers.BatchNorm(), layers.Relu(),
layers.Conv(channels, (3, 3), strides, padding='SAME'),
layers.BatchNorm(), layers.Relu(),
layers.Conv(channels, (3, 3), padding='SAME'))
shortcut = layers.Identity() if not channel_mismatch else layers.Conv(
channels, (3, 3), strides, padding='SAME')
return layers.Serial(
layers.Branch(), layers.Parallel(main, shortcut), layers.SumBranches())
|
[
"def",
"WideResnetBlock",
"(",
"channels",
",",
"strides",
"=",
"(",
"1",
",",
"1",
")",
",",
"channel_mismatch",
"=",
"False",
")",
":",
"main",
"=",
"layers",
".",
"Serial",
"(",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"channels",
",",
"(",
"3",
",",
"3",
")",
",",
"strides",
",",
"padding",
"=",
"'SAME'",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"Conv",
"(",
"channels",
",",
"(",
"3",
",",
"3",
")",
",",
"padding",
"=",
"'SAME'",
")",
")",
"shortcut",
"=",
"layers",
".",
"Identity",
"(",
")",
"if",
"not",
"channel_mismatch",
"else",
"layers",
".",
"Conv",
"(",
"channels",
",",
"(",
"3",
",",
"3",
")",
",",
"strides",
",",
"padding",
"=",
"'SAME'",
")",
"return",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Branch",
"(",
")",
",",
"layers",
".",
"Parallel",
"(",
"main",
",",
"shortcut",
")",
",",
"layers",
".",
"SumBranches",
"(",
")",
")"
] |
WideResnet convolutational block.
|
[
"WideResnet",
"convolutational",
"block",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/models/resnet.py#L109-L118
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/models/resnet.py
|
WideResnet
|
def WideResnet(num_blocks=3, hidden_size=64, num_output_classes=10,
mode='train'):
"""WideResnet from https://arxiv.org/pdf/1605.07146.pdf.
Args:
num_blocks: int, number of blocks in a group.
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: int, number of classes to distinguish.
mode: is it training or eval.
Returns:
The WideResnet model with given layer and output sizes.
"""
del mode
return layers.Serial(
layers.Conv(hidden_size, (3, 3), padding='SAME'),
WideResnetGroup(num_blocks, hidden_size),
WideResnetGroup(num_blocks, hidden_size * 2, (2, 2)),
WideResnetGroup(num_blocks, hidden_size * 4, (2, 2)), layers.BatchNorm(),
layers.Relu(), layers.AvgPool(pool_size=(8, 8)), layers.Flatten(),
layers.Dense(num_output_classes), layers.LogSoftmax())
|
python
|
def WideResnet(num_blocks=3, hidden_size=64, num_output_classes=10,
mode='train'):
"""WideResnet from https://arxiv.org/pdf/1605.07146.pdf.
Args:
num_blocks: int, number of blocks in a group.
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: int, number of classes to distinguish.
mode: is it training or eval.
Returns:
The WideResnet model with given layer and output sizes.
"""
del mode
return layers.Serial(
layers.Conv(hidden_size, (3, 3), padding='SAME'),
WideResnetGroup(num_blocks, hidden_size),
WideResnetGroup(num_blocks, hidden_size * 2, (2, 2)),
WideResnetGroup(num_blocks, hidden_size * 4, (2, 2)), layers.BatchNorm(),
layers.Relu(), layers.AvgPool(pool_size=(8, 8)), layers.Flatten(),
layers.Dense(num_output_classes), layers.LogSoftmax())
|
[
"def",
"WideResnet",
"(",
"num_blocks",
"=",
"3",
",",
"hidden_size",
"=",
"64",
",",
"num_output_classes",
"=",
"10",
",",
"mode",
"=",
"'train'",
")",
":",
"del",
"mode",
"return",
"layers",
".",
"Serial",
"(",
"layers",
".",
"Conv",
"(",
"hidden_size",
",",
"(",
"3",
",",
"3",
")",
",",
"padding",
"=",
"'SAME'",
")",
",",
"WideResnetGroup",
"(",
"num_blocks",
",",
"hidden_size",
")",
",",
"WideResnetGroup",
"(",
"num_blocks",
",",
"hidden_size",
"*",
"2",
",",
"(",
"2",
",",
"2",
")",
")",
",",
"WideResnetGroup",
"(",
"num_blocks",
",",
"hidden_size",
"*",
"4",
",",
"(",
"2",
",",
"2",
")",
")",
",",
"layers",
".",
"BatchNorm",
"(",
")",
",",
"layers",
".",
"Relu",
"(",
")",
",",
"layers",
".",
"AvgPool",
"(",
"pool_size",
"=",
"(",
"8",
",",
"8",
")",
")",
",",
"layers",
".",
"Flatten",
"(",
")",
",",
"layers",
".",
"Dense",
"(",
"num_output_classes",
")",
",",
"layers",
".",
"LogSoftmax",
"(",
")",
")"
] |
WideResnet from https://arxiv.org/pdf/1605.07146.pdf.
Args:
num_blocks: int, number of blocks in a group.
hidden_size: the size of the first hidden layer (multiplied later).
num_output_classes: int, number of classes to distinguish.
mode: is it training or eval.
Returns:
The WideResnet model with given layer and output sizes.
|
[
"WideResnet",
"from",
"https",
":",
"//",
"arxiv",
".",
"org",
"/",
"pdf",
"/",
"1605",
".",
"07146",
".",
"pdf",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/models/resnet.py#L129-L149
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/rnn.py
|
GRUCell
|
def GRUCell(units):
"""Builds a traditional GRU cell with dense internal transformations.
Gated Recurrent Unit paper: https://arxiv.org/abs/1412.3555
Args:
units: Number of hidden units.
Returns:
A Stax model representing a traditional GRU RNN cell.
"""
return GeneralGRUCell(
candidate_transform=lambda: core.Dense(units=units),
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh)
|
python
|
def GRUCell(units):
"""Builds a traditional GRU cell with dense internal transformations.
Gated Recurrent Unit paper: https://arxiv.org/abs/1412.3555
Args:
units: Number of hidden units.
Returns:
A Stax model representing a traditional GRU RNN cell.
"""
return GeneralGRUCell(
candidate_transform=lambda: core.Dense(units=units),
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh)
|
[
"def",
"GRUCell",
"(",
"units",
")",
":",
"return",
"GeneralGRUCell",
"(",
"candidate_transform",
"=",
"lambda",
":",
"core",
".",
"Dense",
"(",
"units",
"=",
"units",
")",
",",
"memory_transform",
"=",
"combinators",
".",
"Identity",
",",
"gate_nonlinearity",
"=",
"core",
".",
"Sigmoid",
",",
"candidate_nonlinearity",
"=",
"core",
".",
"Tanh",
")"
] |
Builds a traditional GRU cell with dense internal transformations.
Gated Recurrent Unit paper: https://arxiv.org/abs/1412.3555
Args:
units: Number of hidden units.
Returns:
A Stax model representing a traditional GRU RNN cell.
|
[
"Builds",
"a",
"traditional",
"GRU",
"cell",
"with",
"dense",
"internal",
"transformations",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/rnn.py#L28-L44
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/rnn.py
|
ConvGRUCell
|
def ConvGRUCell(units, kernel_size=(3, 3)):
"""Builds a convolutional GRU.
Paper: https://arxiv.org/abs/1511.06432.
Args:
units: Number of hidden units
kernel_size: Kernel size for convolution
Returns:
A Stax model representing a GRU cell with convolution transforms.
"""
def BuildConv():
return core.Conv(filters=units, kernel_size=kernel_size, padding='SAME')
return GeneralGRUCell(
candidate_transform=BuildConv,
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh)
|
python
|
def ConvGRUCell(units, kernel_size=(3, 3)):
"""Builds a convolutional GRU.
Paper: https://arxiv.org/abs/1511.06432.
Args:
units: Number of hidden units
kernel_size: Kernel size for convolution
Returns:
A Stax model representing a GRU cell with convolution transforms.
"""
def BuildConv():
return core.Conv(filters=units, kernel_size=kernel_size, padding='SAME')
return GeneralGRUCell(
candidate_transform=BuildConv,
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh)
|
[
"def",
"ConvGRUCell",
"(",
"units",
",",
"kernel_size",
"=",
"(",
"3",
",",
"3",
")",
")",
":",
"def",
"BuildConv",
"(",
")",
":",
"return",
"core",
".",
"Conv",
"(",
"filters",
"=",
"units",
",",
"kernel_size",
"=",
"kernel_size",
",",
"padding",
"=",
"'SAME'",
")",
"return",
"GeneralGRUCell",
"(",
"candidate_transform",
"=",
"BuildConv",
",",
"memory_transform",
"=",
"combinators",
".",
"Identity",
",",
"gate_nonlinearity",
"=",
"core",
".",
"Sigmoid",
",",
"candidate_nonlinearity",
"=",
"core",
".",
"Tanh",
")"
] |
Builds a convolutional GRU.
Paper: https://arxiv.org/abs/1511.06432.
Args:
units: Number of hidden units
kernel_size: Kernel size for convolution
Returns:
A Stax model representing a GRU cell with convolution transforms.
|
[
"Builds",
"a",
"convolutional",
"GRU",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/rnn.py#L47-L67
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/rnn.py
|
GeneralGRUCell
|
def GeneralGRUCell(candidate_transform,
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh,
dropout_rate_c=0.1,
sigmoid_bias=0.5):
r"""Parametrized Gated Recurrent Unit (GRU) cell construction.
GRU update equations:
$$ Update gate: u_t = \sigmoid(U' * s_{t-1} + B') $$
$$ Reset gate: r_t = \sigmoid(U'' * s_{t-1} + B'') $$
$$ Candidate memory: c_t = \tanh(U * (r_t \odot s_{t-1}) + B) $$
$$ New State: s_t = u_t \odot s_{t-1} + (1 - u_t) \odot c_t $$
See combinators.GateBranches for details on the gating function.
Args:
candidate_transform: Transform to apply inside the Candidate branch. Applied
before nonlinearities.
memory_transform: Optional transformation on the memory before gating.
gate_nonlinearity: Function to use as gate activation. Allows trying
alternatives to Sigmoid, such as HardSigmoid.
candidate_nonlinearity: Nonlinearity to apply after candidate branch. Allows
trying alternatives to traditional Tanh, such as HardTanh
dropout_rate_c: Amount of dropout on the transform (c) gate. Dropout works
best in a GRU when applied exclusively to this branch.
sigmoid_bias: Constant to add before sigmoid gates. Generally want to start
off with a positive bias.
Returns:
A model representing a GRU cell with specified transforms.
"""
return combinators.Serial(
combinators.Branch(num_branches=3),
combinators.Parallel(
# s_{t-1} branch - optionally transform
# Typically is an identity.
memory_transform(),
# u_t (Update gate) branch
combinators.Serial(
candidate_transform(),
# Want bias to start out positive before sigmoids.
core.AddConstant(constant=sigmoid_bias),
gate_nonlinearity()),
# c_t (Candidate) branch
combinators.Serial(
combinators.Branch(num_branches=2),
combinators.Parallel(
combinators.Identity(),
# r_t (Reset) Branch
combinators.Serial(
candidate_transform(),
# Want bias to start out positive before sigmoids.
core.AddConstant(constant=sigmoid_bias),
gate_nonlinearity())),
## Gate S{t-1} with sigmoid(candidate_transform(S{t-1}))
combinators.MultiplyBranches(),
# Final projection + tanh to get Ct
candidate_transform(),
candidate_nonlinearity()), # Candidate gate
# Only apply dropout on the C gate.
# Paper reports that 0.1 is a good default.
core.Dropout(rate=dropout_rate_c)),
# Gate memory and candidate
combinators.GateBranches())
|
python
|
def GeneralGRUCell(candidate_transform,
memory_transform=combinators.Identity,
gate_nonlinearity=core.Sigmoid,
candidate_nonlinearity=core.Tanh,
dropout_rate_c=0.1,
sigmoid_bias=0.5):
r"""Parametrized Gated Recurrent Unit (GRU) cell construction.
GRU update equations:
$$ Update gate: u_t = \sigmoid(U' * s_{t-1} + B') $$
$$ Reset gate: r_t = \sigmoid(U'' * s_{t-1} + B'') $$
$$ Candidate memory: c_t = \tanh(U * (r_t \odot s_{t-1}) + B) $$
$$ New State: s_t = u_t \odot s_{t-1} + (1 - u_t) \odot c_t $$
See combinators.GateBranches for details on the gating function.
Args:
candidate_transform: Transform to apply inside the Candidate branch. Applied
before nonlinearities.
memory_transform: Optional transformation on the memory before gating.
gate_nonlinearity: Function to use as gate activation. Allows trying
alternatives to Sigmoid, such as HardSigmoid.
candidate_nonlinearity: Nonlinearity to apply after candidate branch. Allows
trying alternatives to traditional Tanh, such as HardTanh
dropout_rate_c: Amount of dropout on the transform (c) gate. Dropout works
best in a GRU when applied exclusively to this branch.
sigmoid_bias: Constant to add before sigmoid gates. Generally want to start
off with a positive bias.
Returns:
A model representing a GRU cell with specified transforms.
"""
return combinators.Serial(
combinators.Branch(num_branches=3),
combinators.Parallel(
# s_{t-1} branch - optionally transform
# Typically is an identity.
memory_transform(),
# u_t (Update gate) branch
combinators.Serial(
candidate_transform(),
# Want bias to start out positive before sigmoids.
core.AddConstant(constant=sigmoid_bias),
gate_nonlinearity()),
# c_t (Candidate) branch
combinators.Serial(
combinators.Branch(num_branches=2),
combinators.Parallel(
combinators.Identity(),
# r_t (Reset) Branch
combinators.Serial(
candidate_transform(),
# Want bias to start out positive before sigmoids.
core.AddConstant(constant=sigmoid_bias),
gate_nonlinearity())),
## Gate S{t-1} with sigmoid(candidate_transform(S{t-1}))
combinators.MultiplyBranches(),
# Final projection + tanh to get Ct
candidate_transform(),
candidate_nonlinearity()), # Candidate gate
# Only apply dropout on the C gate.
# Paper reports that 0.1 is a good default.
core.Dropout(rate=dropout_rate_c)),
# Gate memory and candidate
combinators.GateBranches())
|
[
"def",
"GeneralGRUCell",
"(",
"candidate_transform",
",",
"memory_transform",
"=",
"combinators",
".",
"Identity",
",",
"gate_nonlinearity",
"=",
"core",
".",
"Sigmoid",
",",
"candidate_nonlinearity",
"=",
"core",
".",
"Tanh",
",",
"dropout_rate_c",
"=",
"0.1",
",",
"sigmoid_bias",
"=",
"0.5",
")",
":",
"return",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Branch",
"(",
"num_branches",
"=",
"3",
")",
",",
"combinators",
".",
"Parallel",
"(",
"# s_{t-1} branch - optionally transform",
"# Typically is an identity.",
"memory_transform",
"(",
")",
",",
"# u_t (Update gate) branch",
"combinators",
".",
"Serial",
"(",
"candidate_transform",
"(",
")",
",",
"# Want bias to start out positive before sigmoids.",
"core",
".",
"AddConstant",
"(",
"constant",
"=",
"sigmoid_bias",
")",
",",
"gate_nonlinearity",
"(",
")",
")",
",",
"# c_t (Candidate) branch",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Branch",
"(",
"num_branches",
"=",
"2",
")",
",",
"combinators",
".",
"Parallel",
"(",
"combinators",
".",
"Identity",
"(",
")",
",",
"# r_t (Reset) Branch",
"combinators",
".",
"Serial",
"(",
"candidate_transform",
"(",
")",
",",
"# Want bias to start out positive before sigmoids.",
"core",
".",
"AddConstant",
"(",
"constant",
"=",
"sigmoid_bias",
")",
",",
"gate_nonlinearity",
"(",
")",
")",
")",
",",
"## Gate S{t-1} with sigmoid(candidate_transform(S{t-1}))",
"combinators",
".",
"MultiplyBranches",
"(",
")",
",",
"# Final projection + tanh to get Ct",
"candidate_transform",
"(",
")",
",",
"candidate_nonlinearity",
"(",
")",
")",
",",
"# Candidate gate",
"# Only apply dropout on the C gate.",
"# Paper reports that 0.1 is a good default.",
"core",
".",
"Dropout",
"(",
"rate",
"=",
"dropout_rate_c",
")",
")",
",",
"# Gate memory and candidate",
"combinators",
".",
"GateBranches",
"(",
")",
")"
] |
r"""Parametrized Gated Recurrent Unit (GRU) cell construction.
GRU update equations:
$$ Update gate: u_t = \sigmoid(U' * s_{t-1} + B') $$
$$ Reset gate: r_t = \sigmoid(U'' * s_{t-1} + B'') $$
$$ Candidate memory: c_t = \tanh(U * (r_t \odot s_{t-1}) + B) $$
$$ New State: s_t = u_t \odot s_{t-1} + (1 - u_t) \odot c_t $$
See combinators.GateBranches for details on the gating function.
Args:
candidate_transform: Transform to apply inside the Candidate branch. Applied
before nonlinearities.
memory_transform: Optional transformation on the memory before gating.
gate_nonlinearity: Function to use as gate activation. Allows trying
alternatives to Sigmoid, such as HardSigmoid.
candidate_nonlinearity: Nonlinearity to apply after candidate branch. Allows
trying alternatives to traditional Tanh, such as HardTanh
dropout_rate_c: Amount of dropout on the transform (c) gate. Dropout works
best in a GRU when applied exclusively to this branch.
sigmoid_bias: Constant to add before sigmoid gates. Generally want to start
off with a positive bias.
Returns:
A model representing a GRU cell with specified transforms.
|
[
"r",
"Parametrized",
"Gated",
"Recurrent",
"Unit",
"(",
"GRU",
")",
"cell",
"construction",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/rnn.py#L70-L140
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
MakeTargetMask
|
def MakeTargetMask(target, pad=0):
"""Create an attention mask to hide padding and future words."""
target_mask = (target != pad)[ :, np.newaxis, :]
target_dtype = target_mask.dtype
causal_mask = onp.tril(onp.ones((1, target.shape[-1], target.shape[-1]),
dtype=target_dtype), k=0)
target_mask = target_mask & causal_mask
return np.expand_dims(target_mask, axis=1)
|
python
|
def MakeTargetMask(target, pad=0):
"""Create an attention mask to hide padding and future words."""
target_mask = (target != pad)[ :, np.newaxis, :]
target_dtype = target_mask.dtype
causal_mask = onp.tril(onp.ones((1, target.shape[-1], target.shape[-1]),
dtype=target_dtype), k=0)
target_mask = target_mask & causal_mask
return np.expand_dims(target_mask, axis=1)
|
[
"def",
"MakeTargetMask",
"(",
"target",
",",
"pad",
"=",
"0",
")",
":",
"target_mask",
"=",
"(",
"target",
"!=",
"pad",
")",
"[",
":",
",",
"np",
".",
"newaxis",
",",
":",
"]",
"target_dtype",
"=",
"target_mask",
".",
"dtype",
"causal_mask",
"=",
"onp",
".",
"tril",
"(",
"onp",
".",
"ones",
"(",
"(",
"1",
",",
"target",
".",
"shape",
"[",
"-",
"1",
"]",
",",
"target",
".",
"shape",
"[",
"-",
"1",
"]",
")",
",",
"dtype",
"=",
"target_dtype",
")",
",",
"k",
"=",
"0",
")",
"target_mask",
"=",
"target_mask",
"&",
"causal_mask",
"return",
"np",
".",
"expand_dims",
"(",
"target_mask",
",",
"axis",
"=",
"1",
")"
] |
Create an attention mask to hide padding and future words.
|
[
"Create",
"an",
"attention",
"mask",
"to",
"hide",
"padding",
"and",
"future",
"words",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L43-L50
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
PreparePairedSequenceBatch
|
def PreparePairedSequenceBatch(source, target_in, pad=0):
"""Build masks for this batch.
Args:
source: (batch, source_len) array of integer-coded symbols for inputs
target_in: (batch, batch_len) array of integer-coded symbols for targets
pad: int: the padding symbol used to pad the above
Returns:
Prepared batch of tuple of arrays: source, input-target, shifted-target,
source mask, target mask, source-target "memory" mask, minibatch token count
"""
target = target_in[:, :-1]
target_y = target_in[:, 1:]
source_mask = np.reshape(source != pad,
(source.shape[0], 1, 1, source.shape[-1]))
target_mask = MakeTargetMask(target, pad)
memory_mask = (
np.reshape(np.arange(target.shape[-1]) < source.shape[-1], [-1, 1]))
ntokens = np.sum(target_y != pad)
return (source, target, target_y,
source_mask, target_mask, memory_mask, ntokens)
|
python
|
def PreparePairedSequenceBatch(source, target_in, pad=0):
"""Build masks for this batch.
Args:
source: (batch, source_len) array of integer-coded symbols for inputs
target_in: (batch, batch_len) array of integer-coded symbols for targets
pad: int: the padding symbol used to pad the above
Returns:
Prepared batch of tuple of arrays: source, input-target, shifted-target,
source mask, target mask, source-target "memory" mask, minibatch token count
"""
target = target_in[:, :-1]
target_y = target_in[:, 1:]
source_mask = np.reshape(source != pad,
(source.shape[0], 1, 1, source.shape[-1]))
target_mask = MakeTargetMask(target, pad)
memory_mask = (
np.reshape(np.arange(target.shape[-1]) < source.shape[-1], [-1, 1]))
ntokens = np.sum(target_y != pad)
return (source, target, target_y,
source_mask, target_mask, memory_mask, ntokens)
|
[
"def",
"PreparePairedSequenceBatch",
"(",
"source",
",",
"target_in",
",",
"pad",
"=",
"0",
")",
":",
"target",
"=",
"target_in",
"[",
":",
",",
":",
"-",
"1",
"]",
"target_y",
"=",
"target_in",
"[",
":",
",",
"1",
":",
"]",
"source_mask",
"=",
"np",
".",
"reshape",
"(",
"source",
"!=",
"pad",
",",
"(",
"source",
".",
"shape",
"[",
"0",
"]",
",",
"1",
",",
"1",
",",
"source",
".",
"shape",
"[",
"-",
"1",
"]",
")",
")",
"target_mask",
"=",
"MakeTargetMask",
"(",
"target",
",",
"pad",
")",
"memory_mask",
"=",
"(",
"np",
".",
"reshape",
"(",
"np",
".",
"arange",
"(",
"target",
".",
"shape",
"[",
"-",
"1",
"]",
")",
"<",
"source",
".",
"shape",
"[",
"-",
"1",
"]",
",",
"[",
"-",
"1",
",",
"1",
"]",
")",
")",
"ntokens",
"=",
"np",
".",
"sum",
"(",
"target_y",
"!=",
"pad",
")",
"return",
"(",
"source",
",",
"target",
",",
"target_y",
",",
"source_mask",
",",
"target_mask",
",",
"memory_mask",
",",
"ntokens",
")"
] |
Build masks for this batch.
Args:
source: (batch, source_len) array of integer-coded symbols for inputs
target_in: (batch, batch_len) array of integer-coded symbols for targets
pad: int: the padding symbol used to pad the above
Returns:
Prepared batch of tuple of arrays: source, input-target, shifted-target,
source mask, target mask, source-target "memory" mask, minibatch token count
|
[
"Build",
"masks",
"for",
"this",
"batch",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L53-L74
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
_layer_norm_new_params
|
def _layer_norm_new_params(input_shape, rng, epsilon=1e-6): # pylint: disable=invalid-name
"""Helper: create layer norm parameters."""
del rng, epsilon
features = input_shape[-1]
scale = np.ones(features)
bias = np.zeros(features)
return (scale, bias)
|
python
|
def _layer_norm_new_params(input_shape, rng, epsilon=1e-6): # pylint: disable=invalid-name
"""Helper: create layer norm parameters."""
del rng, epsilon
features = input_shape[-1]
scale = np.ones(features)
bias = np.zeros(features)
return (scale, bias)
|
[
"def",
"_layer_norm_new_params",
"(",
"input_shape",
",",
"rng",
",",
"epsilon",
"=",
"1e-6",
")",
":",
"# pylint: disable=invalid-name",
"del",
"rng",
",",
"epsilon",
"features",
"=",
"input_shape",
"[",
"-",
"1",
"]",
"scale",
"=",
"np",
".",
"ones",
"(",
"features",
")",
"bias",
"=",
"np",
".",
"zeros",
"(",
"features",
")",
"return",
"(",
"scale",
",",
"bias",
")"
] |
Helper: create layer norm parameters.
|
[
"Helper",
":",
"create",
"layer",
"norm",
"parameters",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L78-L84
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
_positional_encoding_new_params
|
def _positional_encoding_new_params(input_shape, rng, max_len=2048): # pylint: disable=invalid-name
"""Helper: create positional encoding parameters."""
del rng
# Check if we are operating on chunked inputs by checking if the first
# shape is a list/tuple of shapes (otherwise it's an int or numpy array).
is_chunked = isinstance(input_shape[0], (list, tuple))
feature_depth = input_shape[0][-1] if is_chunked else input_shape[-1]
pe = onp.zeros((max_len, feature_depth), dtype=onp.float32)
position = onp.arange(0, max_len)[:, onp.newaxis]
div_term = onp.exp(
onp.arange(0, feature_depth, 2) * -(onp.log(10000.0) / feature_depth))
pe[:, 0::2] = onp.sin(position * div_term)
pe[:, 1::2] = onp.cos(position * div_term)
pe = pe[onp.newaxis, :, :] # [1, max_len, feature_depth]
return np.array(pe)
|
python
|
def _positional_encoding_new_params(input_shape, rng, max_len=2048): # pylint: disable=invalid-name
"""Helper: create positional encoding parameters."""
del rng
# Check if we are operating on chunked inputs by checking if the first
# shape is a list/tuple of shapes (otherwise it's an int or numpy array).
is_chunked = isinstance(input_shape[0], (list, tuple))
feature_depth = input_shape[0][-1] if is_chunked else input_shape[-1]
pe = onp.zeros((max_len, feature_depth), dtype=onp.float32)
position = onp.arange(0, max_len)[:, onp.newaxis]
div_term = onp.exp(
onp.arange(0, feature_depth, 2) * -(onp.log(10000.0) / feature_depth))
pe[:, 0::2] = onp.sin(position * div_term)
pe[:, 1::2] = onp.cos(position * div_term)
pe = pe[onp.newaxis, :, :] # [1, max_len, feature_depth]
return np.array(pe)
|
[
"def",
"_positional_encoding_new_params",
"(",
"input_shape",
",",
"rng",
",",
"max_len",
"=",
"2048",
")",
":",
"# pylint: disable=invalid-name",
"del",
"rng",
"# Check if we are operating on chunked inputs by checking if the first",
"# shape is a list/tuple of shapes (otherwise it's an int or numpy array).",
"is_chunked",
"=",
"isinstance",
"(",
"input_shape",
"[",
"0",
"]",
",",
"(",
"list",
",",
"tuple",
")",
")",
"feature_depth",
"=",
"input_shape",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
"if",
"is_chunked",
"else",
"input_shape",
"[",
"-",
"1",
"]",
"pe",
"=",
"onp",
".",
"zeros",
"(",
"(",
"max_len",
",",
"feature_depth",
")",
",",
"dtype",
"=",
"onp",
".",
"float32",
")",
"position",
"=",
"onp",
".",
"arange",
"(",
"0",
",",
"max_len",
")",
"[",
":",
",",
"onp",
".",
"newaxis",
"]",
"div_term",
"=",
"onp",
".",
"exp",
"(",
"onp",
".",
"arange",
"(",
"0",
",",
"feature_depth",
",",
"2",
")",
"*",
"-",
"(",
"onp",
".",
"log",
"(",
"10000.0",
")",
"/",
"feature_depth",
")",
")",
"pe",
"[",
":",
",",
"0",
":",
":",
"2",
"]",
"=",
"onp",
".",
"sin",
"(",
"position",
"*",
"div_term",
")",
"pe",
"[",
":",
",",
"1",
":",
":",
"2",
"]",
"=",
"onp",
".",
"cos",
"(",
"position",
"*",
"div_term",
")",
"pe",
"=",
"pe",
"[",
"onp",
".",
"newaxis",
",",
":",
",",
":",
"]",
"# [1, max_len, feature_depth]",
"return",
"np",
".",
"array",
"(",
"pe",
")"
] |
Helper: create positional encoding parameters.
|
[
"Helper",
":",
"create",
"positional",
"encoding",
"parameters",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L97-L111
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
PositionalEncoding
|
def PositionalEncoding(x, params, **unused_kwargs):
"""Implements bare positional encoding."""
if not isinstance(x, (list, tuple)): # non-chunked inputs
symbol_size = np.shape(x)[1]
return x + params[:, :symbol_size, :]
# Chunked case: apply to all chunks selecting as much as needed.
offset = 0
results = []
for chunk in x:
symbol_size = np.shape(chunk)[1]
results.append(chunk + params[:, offset:offset + symbol_size, :])
offset += symbol_size
return results
|
python
|
def PositionalEncoding(x, params, **unused_kwargs):
"""Implements bare positional encoding."""
if not isinstance(x, (list, tuple)): # non-chunked inputs
symbol_size = np.shape(x)[1]
return x + params[:, :symbol_size, :]
# Chunked case: apply to all chunks selecting as much as needed.
offset = 0
results = []
for chunk in x:
symbol_size = np.shape(chunk)[1]
results.append(chunk + params[:, offset:offset + symbol_size, :])
offset += symbol_size
return results
|
[
"def",
"PositionalEncoding",
"(",
"x",
",",
"params",
",",
"*",
"*",
"unused_kwargs",
")",
":",
"if",
"not",
"isinstance",
"(",
"x",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"# non-chunked inputs",
"symbol_size",
"=",
"np",
".",
"shape",
"(",
"x",
")",
"[",
"1",
"]",
"return",
"x",
"+",
"params",
"[",
":",
",",
":",
"symbol_size",
",",
":",
"]",
"# Chunked case: apply to all chunks selecting as much as needed.",
"offset",
"=",
"0",
"results",
"=",
"[",
"]",
"for",
"chunk",
"in",
"x",
":",
"symbol_size",
"=",
"np",
".",
"shape",
"(",
"chunk",
")",
"[",
"1",
"]",
"results",
".",
"append",
"(",
"chunk",
"+",
"params",
"[",
":",
",",
"offset",
":",
"offset",
"+",
"symbol_size",
",",
":",
"]",
")",
"offset",
"+=",
"symbol_size",
"return",
"results"
] |
Implements bare positional encoding.
|
[
"Implements",
"bare",
"positional",
"encoding",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L115-L127
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
DotProductAttention
|
def DotProductAttention(query, key, value, mask, dropout, mode, rng):
"""Core dot product self-attention.
Args:
query: array of representations
key: array of representations
value: array of representations
mask: attention-mask, gates attention
dropout: float: dropout rate
mode: 'eval' or 'train': whether to use dropout
rng: JAX PRNGKey: subkey for disposable use
Returns:
Self attention for q, k, v arrays.
"""
depth = np.shape(query)[-1]
dots = np.matmul(query, np.swapaxes(key, -1, -2)) / np.sqrt(depth)
if mask is not None:
dots = np.where(mask, dots, -1e9)
# Softmax.
dots = np.exp(dots - backend.logsumexp(dots, axis=-1, keepdims=True))
if dropout >= 1.0:
raise ValueError('Dropout rates must be lower than 1.')
if dropout is not None and dropout > 0.0 and mode == 'train':
keep = backend.random.bernoulli(rng, 1.0 - dropout, dots.shape)
dots = np.where(keep, dots / (1.0 - dropout), 0)
out = np.matmul(dots, value)
return out
|
python
|
def DotProductAttention(query, key, value, mask, dropout, mode, rng):
"""Core dot product self-attention.
Args:
query: array of representations
key: array of representations
value: array of representations
mask: attention-mask, gates attention
dropout: float: dropout rate
mode: 'eval' or 'train': whether to use dropout
rng: JAX PRNGKey: subkey for disposable use
Returns:
Self attention for q, k, v arrays.
"""
depth = np.shape(query)[-1]
dots = np.matmul(query, np.swapaxes(key, -1, -2)) / np.sqrt(depth)
if mask is not None:
dots = np.where(mask, dots, -1e9)
# Softmax.
dots = np.exp(dots - backend.logsumexp(dots, axis=-1, keepdims=True))
if dropout >= 1.0:
raise ValueError('Dropout rates must be lower than 1.')
if dropout is not None and dropout > 0.0 and mode == 'train':
keep = backend.random.bernoulli(rng, 1.0 - dropout, dots.shape)
dots = np.where(keep, dots / (1.0 - dropout), 0)
out = np.matmul(dots, value)
return out
|
[
"def",
"DotProductAttention",
"(",
"query",
",",
"key",
",",
"value",
",",
"mask",
",",
"dropout",
",",
"mode",
",",
"rng",
")",
":",
"depth",
"=",
"np",
".",
"shape",
"(",
"query",
")",
"[",
"-",
"1",
"]",
"dots",
"=",
"np",
".",
"matmul",
"(",
"query",
",",
"np",
".",
"swapaxes",
"(",
"key",
",",
"-",
"1",
",",
"-",
"2",
")",
")",
"/",
"np",
".",
"sqrt",
"(",
"depth",
")",
"if",
"mask",
"is",
"not",
"None",
":",
"dots",
"=",
"np",
".",
"where",
"(",
"mask",
",",
"dots",
",",
"-",
"1e9",
")",
"# Softmax.",
"dots",
"=",
"np",
".",
"exp",
"(",
"dots",
"-",
"backend",
".",
"logsumexp",
"(",
"dots",
",",
"axis",
"=",
"-",
"1",
",",
"keepdims",
"=",
"True",
")",
")",
"if",
"dropout",
">=",
"1.0",
":",
"raise",
"ValueError",
"(",
"'Dropout rates must be lower than 1.'",
")",
"if",
"dropout",
"is",
"not",
"None",
"and",
"dropout",
">",
"0.0",
"and",
"mode",
"==",
"'train'",
":",
"keep",
"=",
"backend",
".",
"random",
".",
"bernoulli",
"(",
"rng",
",",
"1.0",
"-",
"dropout",
",",
"dots",
".",
"shape",
")",
"dots",
"=",
"np",
".",
"where",
"(",
"keep",
",",
"dots",
"/",
"(",
"1.0",
"-",
"dropout",
")",
",",
"0",
")",
"out",
"=",
"np",
".",
"matmul",
"(",
"dots",
",",
"value",
")",
"return",
"out"
] |
Core dot product self-attention.
Args:
query: array of representations
key: array of representations
value: array of representations
mask: attention-mask, gates attention
dropout: float: dropout rate
mode: 'eval' or 'train': whether to use dropout
rng: JAX PRNGKey: subkey for disposable use
Returns:
Self attention for q, k, v arrays.
|
[
"Core",
"dot",
"product",
"self",
"-",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L130-L157
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
PureDotProductAttention
|
def PureDotProductAttention(dropout=0.0, mode='train'):
"""Pure single-headed self-attention.
Args:
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Pure single-headed attention layer. (No Dense transforms on input.)
"""
def init_fun(_, input_shapes): # pylint: disable=invalid-name
q_shape, _, v_shape, _ = input_shapes
output_shape = q_shape[:-1] + (v_shape[-1],)
return output_shape, ()
def apply_fun(params, inputs, **kwargs): # pylint: disable=invalid-name
del params
q, k, v, mask = inputs
rng = kwargs.get('rng', None)
return DotProductAttention(q, k, v, mask,
dropout=dropout, mode=mode, rng=rng)
return init_fun, apply_fun
|
python
|
def PureDotProductAttention(dropout=0.0, mode='train'):
"""Pure single-headed self-attention.
Args:
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Pure single-headed attention layer. (No Dense transforms on input.)
"""
def init_fun(_, input_shapes): # pylint: disable=invalid-name
q_shape, _, v_shape, _ = input_shapes
output_shape = q_shape[:-1] + (v_shape[-1],)
return output_shape, ()
def apply_fun(params, inputs, **kwargs): # pylint: disable=invalid-name
del params
q, k, v, mask = inputs
rng = kwargs.get('rng', None)
return DotProductAttention(q, k, v, mask,
dropout=dropout, mode=mode, rng=rng)
return init_fun, apply_fun
|
[
"def",
"PureDotProductAttention",
"(",
"dropout",
"=",
"0.0",
",",
"mode",
"=",
"'train'",
")",
":",
"def",
"init_fun",
"(",
"_",
",",
"input_shapes",
")",
":",
"# pylint: disable=invalid-name",
"q_shape",
",",
"_",
",",
"v_shape",
",",
"_",
"=",
"input_shapes",
"output_shape",
"=",
"q_shape",
"[",
":",
"-",
"1",
"]",
"+",
"(",
"v_shape",
"[",
"-",
"1",
"]",
",",
")",
"return",
"output_shape",
",",
"(",
")",
"def",
"apply_fun",
"(",
"params",
",",
"inputs",
",",
"*",
"*",
"kwargs",
")",
":",
"# pylint: disable=invalid-name",
"del",
"params",
"q",
",",
"k",
",",
"v",
",",
"mask",
"=",
"inputs",
"rng",
"=",
"kwargs",
".",
"get",
"(",
"'rng'",
",",
"None",
")",
"return",
"DotProductAttention",
"(",
"q",
",",
"k",
",",
"v",
",",
"mask",
",",
"dropout",
"=",
"dropout",
",",
"mode",
"=",
"mode",
",",
"rng",
"=",
"rng",
")",
"return",
"init_fun",
",",
"apply_fun"
] |
Pure single-headed self-attention.
Args:
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Pure single-headed attention layer. (No Dense transforms on input.)
|
[
"Pure",
"single",
"-",
"headed",
"self",
"-",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L161-L181
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
PureMultiHeadedAttention
|
def PureMultiHeadedAttention(x, params, num_heads=8, dropout=0.0,
mode='train', **kwargs):
"""Pure transformer-style multi-headed attention.
Args:
x: inputs ((q, k, v), mask)
params: parameters (none)
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
**kwargs: other arguments including the rng
Returns:
Pure Multi-headed attention layer (no Dense transforms on input).
"""
del params
rng = kwargs.get('rng', None)
(q, k, v), mask = x
feature_depth = q.shape[-1]
assert feature_depth % num_heads == 0
head_depth = feature_depth // num_heads
nbatch = np.shape(q)[0]
# nbatch, seqlen, feature_depth --> nbatch, num_heads, seqlen, head_depth
def SplitHeads(x):
return np.transpose(
np.reshape(x, (nbatch, -1, num_heads, head_depth)), (0, 2, 1, 3))
# nbatch, num_heads, seqlen, head_depth --> nbatch, seqlen, feature_depth
def JoinHeads(x): # pylint: disable=invalid-name
return np.reshape(
np.transpose(x, (0, 2, 1, 3)), (nbatch, -1, num_heads*head_depth))
# Split heads, dot-product attention, rejoin heads.
return JoinHeads(
DotProductAttention(
SplitHeads(q), SplitHeads(k), SplitHeads(v), mask,
dropout=dropout, mode=mode, rng=rng))
|
python
|
def PureMultiHeadedAttention(x, params, num_heads=8, dropout=0.0,
mode='train', **kwargs):
"""Pure transformer-style multi-headed attention.
Args:
x: inputs ((q, k, v), mask)
params: parameters (none)
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
**kwargs: other arguments including the rng
Returns:
Pure Multi-headed attention layer (no Dense transforms on input).
"""
del params
rng = kwargs.get('rng', None)
(q, k, v), mask = x
feature_depth = q.shape[-1]
assert feature_depth % num_heads == 0
head_depth = feature_depth // num_heads
nbatch = np.shape(q)[0]
# nbatch, seqlen, feature_depth --> nbatch, num_heads, seqlen, head_depth
def SplitHeads(x):
return np.transpose(
np.reshape(x, (nbatch, -1, num_heads, head_depth)), (0, 2, 1, 3))
# nbatch, num_heads, seqlen, head_depth --> nbatch, seqlen, feature_depth
def JoinHeads(x): # pylint: disable=invalid-name
return np.reshape(
np.transpose(x, (0, 2, 1, 3)), (nbatch, -1, num_heads*head_depth))
# Split heads, dot-product attention, rejoin heads.
return JoinHeads(
DotProductAttention(
SplitHeads(q), SplitHeads(k), SplitHeads(v), mask,
dropout=dropout, mode=mode, rng=rng))
|
[
"def",
"PureMultiHeadedAttention",
"(",
"x",
",",
"params",
",",
"num_heads",
"=",
"8",
",",
"dropout",
"=",
"0.0",
",",
"mode",
"=",
"'train'",
",",
"*",
"*",
"kwargs",
")",
":",
"del",
"params",
"rng",
"=",
"kwargs",
".",
"get",
"(",
"'rng'",
",",
"None",
")",
"(",
"q",
",",
"k",
",",
"v",
")",
",",
"mask",
"=",
"x",
"feature_depth",
"=",
"q",
".",
"shape",
"[",
"-",
"1",
"]",
"assert",
"feature_depth",
"%",
"num_heads",
"==",
"0",
"head_depth",
"=",
"feature_depth",
"//",
"num_heads",
"nbatch",
"=",
"np",
".",
"shape",
"(",
"q",
")",
"[",
"0",
"]",
"# nbatch, seqlen, feature_depth --> nbatch, num_heads, seqlen, head_depth",
"def",
"SplitHeads",
"(",
"x",
")",
":",
"return",
"np",
".",
"transpose",
"(",
"np",
".",
"reshape",
"(",
"x",
",",
"(",
"nbatch",
",",
"-",
"1",
",",
"num_heads",
",",
"head_depth",
")",
")",
",",
"(",
"0",
",",
"2",
",",
"1",
",",
"3",
")",
")",
"# nbatch, num_heads, seqlen, head_depth --> nbatch, seqlen, feature_depth",
"def",
"JoinHeads",
"(",
"x",
")",
":",
"# pylint: disable=invalid-name",
"return",
"np",
".",
"reshape",
"(",
"np",
".",
"transpose",
"(",
"x",
",",
"(",
"0",
",",
"2",
",",
"1",
",",
"3",
")",
")",
",",
"(",
"nbatch",
",",
"-",
"1",
",",
"num_heads",
"*",
"head_depth",
")",
")",
"# Split heads, dot-product attention, rejoin heads.",
"return",
"JoinHeads",
"(",
"DotProductAttention",
"(",
"SplitHeads",
"(",
"q",
")",
",",
"SplitHeads",
"(",
"k",
")",
",",
"SplitHeads",
"(",
"v",
")",
",",
"mask",
",",
"dropout",
"=",
"dropout",
",",
"mode",
"=",
"mode",
",",
"rng",
"=",
"rng",
")",
")"
] |
Pure transformer-style multi-headed attention.
Args:
x: inputs ((q, k, v), mask)
params: parameters (none)
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
**kwargs: other arguments including the rng
Returns:
Pure Multi-headed attention layer (no Dense transforms on input).
|
[
"Pure",
"transformer",
"-",
"style",
"multi",
"-",
"headed",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L192-L226
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
MultiHeadedAttentionQKV
|
def MultiHeadedAttentionQKV(
feature_depth, num_heads=8, dropout=0.0, mode='train'):
"""Transformer-style multi-headed attention.
Accepts inputs of the form (q, k, v), mask.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
return combinators.Serial(
combinators.Parallel(
combinators.Parallel(
core.Dense(feature_depth),
core.Dense(feature_depth),
core.Dense(feature_depth),
),
combinators.Identity()
),
PureMultiHeadedAttention( # pylint: disable=no-value-for-parameter
feature_depth=feature_depth, num_heads=num_heads,
dropout=dropout, mode=mode),
core.Dense(feature_depth),
)
|
python
|
def MultiHeadedAttentionQKV(
feature_depth, num_heads=8, dropout=0.0, mode='train'):
"""Transformer-style multi-headed attention.
Accepts inputs of the form (q, k, v), mask.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
return combinators.Serial(
combinators.Parallel(
combinators.Parallel(
core.Dense(feature_depth),
core.Dense(feature_depth),
core.Dense(feature_depth),
),
combinators.Identity()
),
PureMultiHeadedAttention( # pylint: disable=no-value-for-parameter
feature_depth=feature_depth, num_heads=num_heads,
dropout=dropout, mode=mode),
core.Dense(feature_depth),
)
|
[
"def",
"MultiHeadedAttentionQKV",
"(",
"feature_depth",
",",
"num_heads",
"=",
"8",
",",
"dropout",
"=",
"0.0",
",",
"mode",
"=",
"'train'",
")",
":",
"return",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Parallel",
"(",
"combinators",
".",
"Parallel",
"(",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
")",
",",
"combinators",
".",
"Identity",
"(",
")",
")",
",",
"PureMultiHeadedAttention",
"(",
"# pylint: disable=no-value-for-parameter",
"feature_depth",
"=",
"feature_depth",
",",
"num_heads",
"=",
"num_heads",
",",
"dropout",
"=",
"dropout",
",",
"mode",
"=",
"mode",
")",
",",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
")"
] |
Transformer-style multi-headed attention.
Accepts inputs of the form (q, k, v), mask.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
|
[
"Transformer",
"-",
"style",
"multi",
"-",
"headed",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L229-L257
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
MultiHeadedAttention
|
def MultiHeadedAttention(
feature_depth, num_heads=8, dropout=0.0, mode='train'):
"""Transformer-style multi-headed attention.
Accepts inputs of the form (x, mask) and constructs (q, k, v) from x.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
return combinators.Serial(
combinators.Parallel(
combinators.Branch(num_branches=3), # q = k = v = first input
combinators.Identity() # pass the mask
),
MultiHeadedAttentionQKV( # pylint: disable=no-value-for-parameter
feature_depth, num_heads=num_heads, dropout=dropout, mode=mode),
)
|
python
|
def MultiHeadedAttention(
feature_depth, num_heads=8, dropout=0.0, mode='train'):
"""Transformer-style multi-headed attention.
Accepts inputs of the form (x, mask) and constructs (q, k, v) from x.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
return combinators.Serial(
combinators.Parallel(
combinators.Branch(num_branches=3), # q = k = v = first input
combinators.Identity() # pass the mask
),
MultiHeadedAttentionQKV( # pylint: disable=no-value-for-parameter
feature_depth, num_heads=num_heads, dropout=dropout, mode=mode),
)
|
[
"def",
"MultiHeadedAttention",
"(",
"feature_depth",
",",
"num_heads",
"=",
"8",
",",
"dropout",
"=",
"0.0",
",",
"mode",
"=",
"'train'",
")",
":",
"return",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Parallel",
"(",
"combinators",
".",
"Branch",
"(",
"num_branches",
"=",
"3",
")",
",",
"# q = k = v = first input",
"combinators",
".",
"Identity",
"(",
")",
"# pass the mask",
")",
",",
"MultiHeadedAttentionQKV",
"(",
"# pylint: disable=no-value-for-parameter",
"feature_depth",
",",
"num_heads",
"=",
"num_heads",
",",
"dropout",
"=",
"dropout",
",",
"mode",
"=",
"mode",
")",
",",
")"
] |
Transformer-style multi-headed attention.
Accepts inputs of the form (x, mask) and constructs (q, k, v) from x.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
|
[
"Transformer",
"-",
"style",
"multi",
"-",
"headed",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L260-L282
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
_chunked_selector_output_shape
|
def _chunked_selector_output_shape( # pylint: disable=invalid-name
input_shapes, selector=None, **unused_kwargs):
"""Helper: calculate output shape for chunked key selector (see below)."""
# Read the main function below first, the shape logic just follows the ops.
selector = selector or (lambda x: [] if x < 1 else [x-1])
triples, _ = zip(*input_shapes)
(query_shapes, key_shapes, value_shapes) = zip(*triples)
result = []
for i in range(len(input_shapes)):
selected = selector(i)
cur_key_shape, cur_value_shape = key_shapes[i], value_shapes[i]
# Since keys and values are [batch, length, depth] we concatenate on axis=1.
new_key_len = sum([key_shapes[j][1] for j in selected]) + cur_key_shape[1]
new_key_shape = (cur_key_shape[0], new_key_len, cur_key_shape[2])
new_value_len = sum(
[value_shapes[j][1] for j in selected]) + cur_value_shape[1]
new_value_shape = (cur_value_shape[0], new_value_len, cur_value_shape[2])
# Masks are (1, query-len, key-len).
new_mask_shape = (1, query_shapes[i][1], new_key_len)
new_shape = ((query_shapes[i], new_key_shape, new_value_shape),
new_mask_shape)
result.append(new_shape)
return tuple(result)
|
python
|
def _chunked_selector_output_shape( # pylint: disable=invalid-name
input_shapes, selector=None, **unused_kwargs):
"""Helper: calculate output shape for chunked key selector (see below)."""
# Read the main function below first, the shape logic just follows the ops.
selector = selector or (lambda x: [] if x < 1 else [x-1])
triples, _ = zip(*input_shapes)
(query_shapes, key_shapes, value_shapes) = zip(*triples)
result = []
for i in range(len(input_shapes)):
selected = selector(i)
cur_key_shape, cur_value_shape = key_shapes[i], value_shapes[i]
# Since keys and values are [batch, length, depth] we concatenate on axis=1.
new_key_len = sum([key_shapes[j][1] for j in selected]) + cur_key_shape[1]
new_key_shape = (cur_key_shape[0], new_key_len, cur_key_shape[2])
new_value_len = sum(
[value_shapes[j][1] for j in selected]) + cur_value_shape[1]
new_value_shape = (cur_value_shape[0], new_value_len, cur_value_shape[2])
# Masks are (1, query-len, key-len).
new_mask_shape = (1, query_shapes[i][1], new_key_len)
new_shape = ((query_shapes[i], new_key_shape, new_value_shape),
new_mask_shape)
result.append(new_shape)
return tuple(result)
|
[
"def",
"_chunked_selector_output_shape",
"(",
"# pylint: disable=invalid-name",
"input_shapes",
",",
"selector",
"=",
"None",
",",
"*",
"*",
"unused_kwargs",
")",
":",
"# Read the main function below first, the shape logic just follows the ops.",
"selector",
"=",
"selector",
"or",
"(",
"lambda",
"x",
":",
"[",
"]",
"if",
"x",
"<",
"1",
"else",
"[",
"x",
"-",
"1",
"]",
")",
"triples",
",",
"_",
"=",
"zip",
"(",
"*",
"input_shapes",
")",
"(",
"query_shapes",
",",
"key_shapes",
",",
"value_shapes",
")",
"=",
"zip",
"(",
"*",
"triples",
")",
"result",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"input_shapes",
")",
")",
":",
"selected",
"=",
"selector",
"(",
"i",
")",
"cur_key_shape",
",",
"cur_value_shape",
"=",
"key_shapes",
"[",
"i",
"]",
",",
"value_shapes",
"[",
"i",
"]",
"# Since keys and values are [batch, length, depth] we concatenate on axis=1.",
"new_key_len",
"=",
"sum",
"(",
"[",
"key_shapes",
"[",
"j",
"]",
"[",
"1",
"]",
"for",
"j",
"in",
"selected",
"]",
")",
"+",
"cur_key_shape",
"[",
"1",
"]",
"new_key_shape",
"=",
"(",
"cur_key_shape",
"[",
"0",
"]",
",",
"new_key_len",
",",
"cur_key_shape",
"[",
"2",
"]",
")",
"new_value_len",
"=",
"sum",
"(",
"[",
"value_shapes",
"[",
"j",
"]",
"[",
"1",
"]",
"for",
"j",
"in",
"selected",
"]",
")",
"+",
"cur_value_shape",
"[",
"1",
"]",
"new_value_shape",
"=",
"(",
"cur_value_shape",
"[",
"0",
"]",
",",
"new_value_len",
",",
"cur_value_shape",
"[",
"2",
"]",
")",
"# Masks are (1, query-len, key-len).",
"new_mask_shape",
"=",
"(",
"1",
",",
"query_shapes",
"[",
"i",
"]",
"[",
"1",
"]",
",",
"new_key_len",
")",
"new_shape",
"=",
"(",
"(",
"query_shapes",
"[",
"i",
"]",
",",
"new_key_shape",
",",
"new_value_shape",
")",
",",
"new_mask_shape",
")",
"result",
".",
"append",
"(",
"new_shape",
")",
"return",
"tuple",
"(",
"result",
")"
] |
Helper: calculate output shape for chunked key selector (see below).
|
[
"Helper",
":",
"calculate",
"output",
"shape",
"for",
"chunked",
"key",
"selector",
"(",
"see",
"below",
")",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L286-L308
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
ChunkedAttentionSelector
|
def ChunkedAttentionSelector(x, params, selector=None, **kwargs):
"""Select which chunks to attend to in chunked attention.
Args:
x: inputs, a list of elements of the form (q, k, v), mask for each chunk.
params: parameters (unused).
selector: a function from chunk_number -> list of chunk numbers that says
which other chunks should be appended to the given one (previous if None).
**kwargs: unused other arguments.
Returns:
a list of elements of the form (q, k', v'), mask' where k', v' and mask' are
concatenations of k, v and identity-extended masks from selected chunks.
"""
del params, kwargs
selector = selector or (lambda x: [] if x < 1 else [x-1])
triples, masks = zip(*x)
(queries, keys, values) = zip(*triples)
result = []
for i in range(len(x)):
selected = selector(i)
# Since keys and values are [batch, length, depth] we concatenate on axis=1.
# We also always include the current key or value at the end.
new_key_list = [keys[j] for j in selected]
new_key = np.concatenate(new_key_list + [keys[i]], axis=1)
new_value = np.concatenate(
[values[j] for j in selected] + [values[i]], axis=1)
# Masks are (1, query-len, key-len) so we concatenate on axis=2.
new_mask_shapes = [(1, queries[i].shape[1], key.shape[1])
for key in new_key_list]
cur_mask = masks[i]
# Masks are all-1 for the added chunks (no masking).
new_mask_list = [np.ones(s, dtype=cur_mask.dtype) for s in new_mask_shapes]
# We still use the current (often causal) mask for the final chunk.
new_mask = np.concatenate(new_mask_list + [cur_mask], axis=2)
result.append(((queries[i], new_key, new_value), new_mask))
return tuple(result)
|
python
|
def ChunkedAttentionSelector(x, params, selector=None, **kwargs):
"""Select which chunks to attend to in chunked attention.
Args:
x: inputs, a list of elements of the form (q, k, v), mask for each chunk.
params: parameters (unused).
selector: a function from chunk_number -> list of chunk numbers that says
which other chunks should be appended to the given one (previous if None).
**kwargs: unused other arguments.
Returns:
a list of elements of the form (q, k', v'), mask' where k', v' and mask' are
concatenations of k, v and identity-extended masks from selected chunks.
"""
del params, kwargs
selector = selector or (lambda x: [] if x < 1 else [x-1])
triples, masks = zip(*x)
(queries, keys, values) = zip(*triples)
result = []
for i in range(len(x)):
selected = selector(i)
# Since keys and values are [batch, length, depth] we concatenate on axis=1.
# We also always include the current key or value at the end.
new_key_list = [keys[j] for j in selected]
new_key = np.concatenate(new_key_list + [keys[i]], axis=1)
new_value = np.concatenate(
[values[j] for j in selected] + [values[i]], axis=1)
# Masks are (1, query-len, key-len) so we concatenate on axis=2.
new_mask_shapes = [(1, queries[i].shape[1], key.shape[1])
for key in new_key_list]
cur_mask = masks[i]
# Masks are all-1 for the added chunks (no masking).
new_mask_list = [np.ones(s, dtype=cur_mask.dtype) for s in new_mask_shapes]
# We still use the current (often causal) mask for the final chunk.
new_mask = np.concatenate(new_mask_list + [cur_mask], axis=2)
result.append(((queries[i], new_key, new_value), new_mask))
return tuple(result)
|
[
"def",
"ChunkedAttentionSelector",
"(",
"x",
",",
"params",
",",
"selector",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"del",
"params",
",",
"kwargs",
"selector",
"=",
"selector",
"or",
"(",
"lambda",
"x",
":",
"[",
"]",
"if",
"x",
"<",
"1",
"else",
"[",
"x",
"-",
"1",
"]",
")",
"triples",
",",
"masks",
"=",
"zip",
"(",
"*",
"x",
")",
"(",
"queries",
",",
"keys",
",",
"values",
")",
"=",
"zip",
"(",
"*",
"triples",
")",
"result",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"len",
"(",
"x",
")",
")",
":",
"selected",
"=",
"selector",
"(",
"i",
")",
"# Since keys and values are [batch, length, depth] we concatenate on axis=1.",
"# We also always include the current key or value at the end.",
"new_key_list",
"=",
"[",
"keys",
"[",
"j",
"]",
"for",
"j",
"in",
"selected",
"]",
"new_key",
"=",
"np",
".",
"concatenate",
"(",
"new_key_list",
"+",
"[",
"keys",
"[",
"i",
"]",
"]",
",",
"axis",
"=",
"1",
")",
"new_value",
"=",
"np",
".",
"concatenate",
"(",
"[",
"values",
"[",
"j",
"]",
"for",
"j",
"in",
"selected",
"]",
"+",
"[",
"values",
"[",
"i",
"]",
"]",
",",
"axis",
"=",
"1",
")",
"# Masks are (1, query-len, key-len) so we concatenate on axis=2.",
"new_mask_shapes",
"=",
"[",
"(",
"1",
",",
"queries",
"[",
"i",
"]",
".",
"shape",
"[",
"1",
"]",
",",
"key",
".",
"shape",
"[",
"1",
"]",
")",
"for",
"key",
"in",
"new_key_list",
"]",
"cur_mask",
"=",
"masks",
"[",
"i",
"]",
"# Masks are all-1 for the added chunks (no masking).",
"new_mask_list",
"=",
"[",
"np",
".",
"ones",
"(",
"s",
",",
"dtype",
"=",
"cur_mask",
".",
"dtype",
")",
"for",
"s",
"in",
"new_mask_shapes",
"]",
"# We still use the current (often causal) mask for the final chunk.",
"new_mask",
"=",
"np",
".",
"concatenate",
"(",
"new_mask_list",
"+",
"[",
"cur_mask",
"]",
",",
"axis",
"=",
"2",
")",
"result",
".",
"append",
"(",
"(",
"(",
"queries",
"[",
"i",
"]",
",",
"new_key",
",",
"new_value",
")",
",",
"new_mask",
")",
")",
"return",
"tuple",
"(",
"result",
")"
] |
Select which chunks to attend to in chunked attention.
Args:
x: inputs, a list of elements of the form (q, k, v), mask for each chunk.
params: parameters (unused).
selector: a function from chunk_number -> list of chunk numbers that says
which other chunks should be appended to the given one (previous if None).
**kwargs: unused other arguments.
Returns:
a list of elements of the form (q, k', v'), mask' where k', v' and mask' are
concatenations of k, v and identity-extended masks from selected chunks.
|
[
"Select",
"which",
"chunks",
"to",
"attend",
"to",
"in",
"chunked",
"attention",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L312-L348
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
ChunkedCausalMultiHeadedAttention
|
def ChunkedCausalMultiHeadedAttention(
feature_depth, num_heads=8, dropout=0.0, chunk_selector=None, mode='train'):
"""Transformer-style causal multi-headed attention operating on chunks.
Accepts inputs that are a list of chunks and applies causal attention.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
chunk_selector: a function from chunk number to list of chunks to attend.
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
prepare_attention_input = combinators.Serial(
combinators.Branch(),
combinators.Parallel(
combinators.Branch(num_branches=3), # q = k = v = first input
CausalMask(axis=-2), # pylint: disable=no-value-for-parameter
),
combinators.Parallel(
combinators.Parallel(
core.Dense(feature_depth),
core.Dense(feature_depth),
core.Dense(feature_depth),
),
combinators.Identity()
)
)
return combinators.Serial(
combinators.Map(prepare_attention_input),
ChunkedAttentionSelector(selector=chunk_selector), # pylint: disable=no-value-for-parameter
combinators.Map(PureMultiHeadedAttention( # pylint: disable=no-value-for-parameter
feature_depth=feature_depth, num_heads=num_heads,
dropout=dropout, mode=mode), check_shapes=False),
combinators.Map(core.Dense(feature_depth))
)
|
python
|
def ChunkedCausalMultiHeadedAttention(
feature_depth, num_heads=8, dropout=0.0, chunk_selector=None, mode='train'):
"""Transformer-style causal multi-headed attention operating on chunks.
Accepts inputs that are a list of chunks and applies causal attention.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
chunk_selector: a function from chunk number to list of chunks to attend.
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
"""
prepare_attention_input = combinators.Serial(
combinators.Branch(),
combinators.Parallel(
combinators.Branch(num_branches=3), # q = k = v = first input
CausalMask(axis=-2), # pylint: disable=no-value-for-parameter
),
combinators.Parallel(
combinators.Parallel(
core.Dense(feature_depth),
core.Dense(feature_depth),
core.Dense(feature_depth),
),
combinators.Identity()
)
)
return combinators.Serial(
combinators.Map(prepare_attention_input),
ChunkedAttentionSelector(selector=chunk_selector), # pylint: disable=no-value-for-parameter
combinators.Map(PureMultiHeadedAttention( # pylint: disable=no-value-for-parameter
feature_depth=feature_depth, num_heads=num_heads,
dropout=dropout, mode=mode), check_shapes=False),
combinators.Map(core.Dense(feature_depth))
)
|
[
"def",
"ChunkedCausalMultiHeadedAttention",
"(",
"feature_depth",
",",
"num_heads",
"=",
"8",
",",
"dropout",
"=",
"0.0",
",",
"chunk_selector",
"=",
"None",
",",
"mode",
"=",
"'train'",
")",
":",
"prepare_attention_input",
"=",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Branch",
"(",
")",
",",
"combinators",
".",
"Parallel",
"(",
"combinators",
".",
"Branch",
"(",
"num_branches",
"=",
"3",
")",
",",
"# q = k = v = first input",
"CausalMask",
"(",
"axis",
"=",
"-",
"2",
")",
",",
"# pylint: disable=no-value-for-parameter",
")",
",",
"combinators",
".",
"Parallel",
"(",
"combinators",
".",
"Parallel",
"(",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
",",
")",
",",
"combinators",
".",
"Identity",
"(",
")",
")",
")",
"return",
"combinators",
".",
"Serial",
"(",
"combinators",
".",
"Map",
"(",
"prepare_attention_input",
")",
",",
"ChunkedAttentionSelector",
"(",
"selector",
"=",
"chunk_selector",
")",
",",
"# pylint: disable=no-value-for-parameter",
"combinators",
".",
"Map",
"(",
"PureMultiHeadedAttention",
"(",
"# pylint: disable=no-value-for-parameter",
"feature_depth",
"=",
"feature_depth",
",",
"num_heads",
"=",
"num_heads",
",",
"dropout",
"=",
"dropout",
",",
"mode",
"=",
"mode",
")",
",",
"check_shapes",
"=",
"False",
")",
",",
"combinators",
".",
"Map",
"(",
"core",
".",
"Dense",
"(",
"feature_depth",
")",
")",
")"
] |
Transformer-style causal multi-headed attention operating on chunks.
Accepts inputs that are a list of chunks and applies causal attention.
Args:
feature_depth: int: depth of embedding
num_heads: int: number of attention heads
dropout: float: dropout rate
chunk_selector: a function from chunk number to list of chunks to attend.
mode: str: 'train' or 'eval'
Returns:
Multi-headed self-attention layer.
|
[
"Transformer",
"-",
"style",
"causal",
"multi",
"-",
"headed",
"attention",
"operating",
"on",
"chunks",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L351-L389
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/trax/layers/attention.py
|
ShiftRight
|
def ShiftRight(x, **unused_kwargs):
"""Layer to shift the tensor to the right by padding on axis 1."""
if not isinstance(x, (list, tuple)): # non-chunked inputs
pad_widths = [(0, 0), (1, 0)]
padded = np.pad(x, pad_widths, mode='constant')
return padded[:, :-1]
# Handling chunked inputs. Recall that the list of chunks represents a big
# sequence (the concatenation of the chunks). We want to shift that sequence,
# so we put a 0 in the beginning of the first chunk and the last element of
# that chunk is used as the new first element of the next chunk, and so on.
padded = []
last_value = np.zeros_like(x[0][:, -1])
for chunk in x:
padded_chunk = np.concatenate([last_value[:, np.newaxis], chunk], axis=1)
last_value = chunk[:, -1]
padded.append(padded_chunk[:, :-1])
return padded
|
python
|
def ShiftRight(x, **unused_kwargs):
"""Layer to shift the tensor to the right by padding on axis 1."""
if not isinstance(x, (list, tuple)): # non-chunked inputs
pad_widths = [(0, 0), (1, 0)]
padded = np.pad(x, pad_widths, mode='constant')
return padded[:, :-1]
# Handling chunked inputs. Recall that the list of chunks represents a big
# sequence (the concatenation of the chunks). We want to shift that sequence,
# so we put a 0 in the beginning of the first chunk and the last element of
# that chunk is used as the new first element of the next chunk, and so on.
padded = []
last_value = np.zeros_like(x[0][:, -1])
for chunk in x:
padded_chunk = np.concatenate([last_value[:, np.newaxis], chunk], axis=1)
last_value = chunk[:, -1]
padded.append(padded_chunk[:, :-1])
return padded
|
[
"def",
"ShiftRight",
"(",
"x",
",",
"*",
"*",
"unused_kwargs",
")",
":",
"if",
"not",
"isinstance",
"(",
"x",
",",
"(",
"list",
",",
"tuple",
")",
")",
":",
"# non-chunked inputs",
"pad_widths",
"=",
"[",
"(",
"0",
",",
"0",
")",
",",
"(",
"1",
",",
"0",
")",
"]",
"padded",
"=",
"np",
".",
"pad",
"(",
"x",
",",
"pad_widths",
",",
"mode",
"=",
"'constant'",
")",
"return",
"padded",
"[",
":",
",",
":",
"-",
"1",
"]",
"# Handling chunked inputs. Recall that the list of chunks represents a big",
"# sequence (the concatenation of the chunks). We want to shift that sequence,",
"# so we put a 0 in the beginning of the first chunk and the last element of",
"# that chunk is used as the new first element of the next chunk, and so on.",
"padded",
"=",
"[",
"]",
"last_value",
"=",
"np",
".",
"zeros_like",
"(",
"x",
"[",
"0",
"]",
"[",
":",
",",
"-",
"1",
"]",
")",
"for",
"chunk",
"in",
"x",
":",
"padded_chunk",
"=",
"np",
".",
"concatenate",
"(",
"[",
"last_value",
"[",
":",
",",
"np",
".",
"newaxis",
"]",
",",
"chunk",
"]",
",",
"axis",
"=",
"1",
")",
"last_value",
"=",
"chunk",
"[",
":",
",",
"-",
"1",
"]",
"padded",
".",
"append",
"(",
"padded_chunk",
"[",
":",
",",
":",
"-",
"1",
"]",
")",
"return",
"padded"
] |
Layer to shift the tensor to the right by padding on axis 1.
|
[
"Layer",
"to",
"shift",
"the",
"tensor",
"to",
"the",
"right",
"by",
"padding",
"on",
"axis",
"1",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/trax/layers/attention.py#L393-L409
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
zipf_distribution
|
def zipf_distribution(nbr_symbols, alpha):
"""Helper function: Create a Zipf distribution.
Args:
nbr_symbols: number of symbols to use in the distribution.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Returns:
distr_map: list of float, Zipf's distribution over nbr_symbols.
"""
tmp = np.power(np.arange(1, nbr_symbols + 1), -alpha)
zeta = np.r_[0.0, np.cumsum(tmp)]
return [x / zeta[-1] for x in zeta]
|
python
|
def zipf_distribution(nbr_symbols, alpha):
"""Helper function: Create a Zipf distribution.
Args:
nbr_symbols: number of symbols to use in the distribution.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Returns:
distr_map: list of float, Zipf's distribution over nbr_symbols.
"""
tmp = np.power(np.arange(1, nbr_symbols + 1), -alpha)
zeta = np.r_[0.0, np.cumsum(tmp)]
return [x / zeta[-1] for x in zeta]
|
[
"def",
"zipf_distribution",
"(",
"nbr_symbols",
",",
"alpha",
")",
":",
"tmp",
"=",
"np",
".",
"power",
"(",
"np",
".",
"arange",
"(",
"1",
",",
"nbr_symbols",
"+",
"1",
")",
",",
"-",
"alpha",
")",
"zeta",
"=",
"np",
".",
"r_",
"[",
"0.0",
",",
"np",
".",
"cumsum",
"(",
"tmp",
")",
"]",
"return",
"[",
"x",
"/",
"zeta",
"[",
"-",
"1",
"]",
"for",
"x",
"in",
"zeta",
"]"
] |
Helper function: Create a Zipf distribution.
Args:
nbr_symbols: number of symbols to use in the distribution.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Returns:
distr_map: list of float, Zipf's distribution over nbr_symbols.
|
[
"Helper",
"function",
":",
"Create",
"a",
"Zipf",
"distribution",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L208-L223
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
zipf_random_sample
|
def zipf_random_sample(distr_map, sample_len):
"""Helper function: Generate a random Zipf sample of given length.
Args:
distr_map: list of float, Zipf's distribution over nbr_symbols.
sample_len: integer, length of sequence to generate.
Returns:
sample: list of integer, Zipf's random sample over nbr_symbols.
"""
u = np.random.random(sample_len)
# Random produces values in range [0.0,1.0); even if it is almost
# improbable(but possible) that it can generate a clear 0.000..0.
return list(np.searchsorted(distr_map, u))
|
python
|
def zipf_random_sample(distr_map, sample_len):
"""Helper function: Generate a random Zipf sample of given length.
Args:
distr_map: list of float, Zipf's distribution over nbr_symbols.
sample_len: integer, length of sequence to generate.
Returns:
sample: list of integer, Zipf's random sample over nbr_symbols.
"""
u = np.random.random(sample_len)
# Random produces values in range [0.0,1.0); even if it is almost
# improbable(but possible) that it can generate a clear 0.000..0.
return list(np.searchsorted(distr_map, u))
|
[
"def",
"zipf_random_sample",
"(",
"distr_map",
",",
"sample_len",
")",
":",
"u",
"=",
"np",
".",
"random",
".",
"random",
"(",
"sample_len",
")",
"# Random produces values in range [0.0,1.0); even if it is almost",
"# improbable(but possible) that it can generate a clear 0.000..0.",
"return",
"list",
"(",
"np",
".",
"searchsorted",
"(",
"distr_map",
",",
"u",
")",
")"
] |
Helper function: Generate a random Zipf sample of given length.
Args:
distr_map: list of float, Zipf's distribution over nbr_symbols.
sample_len: integer, length of sequence to generate.
Returns:
sample: list of integer, Zipf's random sample over nbr_symbols.
|
[
"Helper",
"function",
":",
"Generate",
"a",
"random",
"Zipf",
"sample",
"of",
"given",
"length",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L226-L240
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
reverse_generator_nlplike
|
def reverse_generator_nlplike(nbr_symbols,
max_length,
nbr_cases,
scale_std_dev=100,
alpha=1.5):
"""Generator for the reversing nlp-like task on sequences of symbols.
The length of the sequence is drawn from a Gaussian(Normal) distribution
at random from [1, max_length] and with std deviation of 1%,
then symbols are drawn from Zipf's law at random from [0, nbr_symbols) until
nbr_cases sequences have been produced.
Args:
nbr_symbols: integer, number of symbols.
max_length: integer, maximum length of sequences to generate.
nbr_cases: the number of cases to generate.
scale_std_dev: float, Normal distribution's standard deviation scale factor
used to draw the length of sequence. Default = 1% of the max_length.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Yields:
A dictionary {"inputs": input-list, "targets": target-list} where
target-list is input-list reversed.
"""
std_dev = max_length / scale_std_dev
distr_map = zipf_distribution(nbr_symbols, alpha)
for _ in range(nbr_cases):
l = int(abs(np.random.normal(loc=max_length / 2, scale=std_dev)) + 1)
inputs = zipf_random_sample(distr_map, l)
yield {"inputs": inputs, "targets": list(reversed(inputs))}
|
python
|
def reverse_generator_nlplike(nbr_symbols,
max_length,
nbr_cases,
scale_std_dev=100,
alpha=1.5):
"""Generator for the reversing nlp-like task on sequences of symbols.
The length of the sequence is drawn from a Gaussian(Normal) distribution
at random from [1, max_length] and with std deviation of 1%,
then symbols are drawn from Zipf's law at random from [0, nbr_symbols) until
nbr_cases sequences have been produced.
Args:
nbr_symbols: integer, number of symbols.
max_length: integer, maximum length of sequences to generate.
nbr_cases: the number of cases to generate.
scale_std_dev: float, Normal distribution's standard deviation scale factor
used to draw the length of sequence. Default = 1% of the max_length.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Yields:
A dictionary {"inputs": input-list, "targets": target-list} where
target-list is input-list reversed.
"""
std_dev = max_length / scale_std_dev
distr_map = zipf_distribution(nbr_symbols, alpha)
for _ in range(nbr_cases):
l = int(abs(np.random.normal(loc=max_length / 2, scale=std_dev)) + 1)
inputs = zipf_random_sample(distr_map, l)
yield {"inputs": inputs, "targets": list(reversed(inputs))}
|
[
"def",
"reverse_generator_nlplike",
"(",
"nbr_symbols",
",",
"max_length",
",",
"nbr_cases",
",",
"scale_std_dev",
"=",
"100",
",",
"alpha",
"=",
"1.5",
")",
":",
"std_dev",
"=",
"max_length",
"/",
"scale_std_dev",
"distr_map",
"=",
"zipf_distribution",
"(",
"nbr_symbols",
",",
"alpha",
")",
"for",
"_",
"in",
"range",
"(",
"nbr_cases",
")",
":",
"l",
"=",
"int",
"(",
"abs",
"(",
"np",
".",
"random",
".",
"normal",
"(",
"loc",
"=",
"max_length",
"/",
"2",
",",
"scale",
"=",
"std_dev",
")",
")",
"+",
"1",
")",
"inputs",
"=",
"zipf_random_sample",
"(",
"distr_map",
",",
"l",
")",
"yield",
"{",
"\"inputs\"",
":",
"inputs",
",",
"\"targets\"",
":",
"list",
"(",
"reversed",
"(",
"inputs",
")",
")",
"}"
] |
Generator for the reversing nlp-like task on sequences of symbols.
The length of the sequence is drawn from a Gaussian(Normal) distribution
at random from [1, max_length] and with std deviation of 1%,
then symbols are drawn from Zipf's law at random from [0, nbr_symbols) until
nbr_cases sequences have been produced.
Args:
nbr_symbols: integer, number of symbols.
max_length: integer, maximum length of sequences to generate.
nbr_cases: the number of cases to generate.
scale_std_dev: float, Normal distribution's standard deviation scale factor
used to draw the length of sequence. Default = 1% of the max_length.
alpha: float, Zipf's Law Distribution parameter. Default = 1.5.
Usually for modelling natural text distribution is in
the range [1.1-1.6].
Yields:
A dictionary {"inputs": input-list, "targets": target-list} where
target-list is input-list reversed.
|
[
"Generator",
"for",
"the",
"reversing",
"nlp",
"-",
"like",
"task",
"on",
"sequences",
"of",
"symbols",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L243-L274
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
lower_endian_to_number
|
def lower_endian_to_number(l, base):
"""Helper function: convert a list of digits in the given base to a number."""
return sum([d * (base**i) for i, d in enumerate(l)])
|
python
|
def lower_endian_to_number(l, base):
"""Helper function: convert a list of digits in the given base to a number."""
return sum([d * (base**i) for i, d in enumerate(l)])
|
[
"def",
"lower_endian_to_number",
"(",
"l",
",",
"base",
")",
":",
"return",
"sum",
"(",
"[",
"d",
"*",
"(",
"base",
"**",
"i",
")",
"for",
"i",
",",
"d",
"in",
"enumerate",
"(",
"l",
")",
"]",
")"
] |
Helper function: convert a list of digits in the given base to a number.
|
[
"Helper",
"function",
":",
"convert",
"a",
"list",
"of",
"digits",
"in",
"the",
"given",
"base",
"to",
"a",
"number",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L311-L313
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
number_to_lower_endian
|
def number_to_lower_endian(n, base):
"""Helper function: convert a number to a list of digits in the given base."""
if n < base:
return [n]
return [n % base] + number_to_lower_endian(n // base, base)
|
python
|
def number_to_lower_endian(n, base):
"""Helper function: convert a number to a list of digits in the given base."""
if n < base:
return [n]
return [n % base] + number_to_lower_endian(n // base, base)
|
[
"def",
"number_to_lower_endian",
"(",
"n",
",",
"base",
")",
":",
"if",
"n",
"<",
"base",
":",
"return",
"[",
"n",
"]",
"return",
"[",
"n",
"%",
"base",
"]",
"+",
"number_to_lower_endian",
"(",
"n",
"//",
"base",
",",
"base",
")"
] |
Helper function: convert a number to a list of digits in the given base.
|
[
"Helper",
"function",
":",
"convert",
"a",
"number",
"to",
"a",
"list",
"of",
"digits",
"in",
"the",
"given",
"base",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L316-L320
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/algorithmic.py
|
random_number_lower_endian
|
def random_number_lower_endian(length, base):
"""Helper function: generate a random number as a lower-endian digits list."""
if length == 1: # Last digit can be 0 only if length is 1.
return [np.random.randint(base)]
prefix = [np.random.randint(base) for _ in range(length - 1)]
return prefix + [np.random.randint(base - 1) + 1]
|
python
|
def random_number_lower_endian(length, base):
"""Helper function: generate a random number as a lower-endian digits list."""
if length == 1: # Last digit can be 0 only if length is 1.
return [np.random.randint(base)]
prefix = [np.random.randint(base) for _ in range(length - 1)]
return prefix + [np.random.randint(base - 1) + 1]
|
[
"def",
"random_number_lower_endian",
"(",
"length",
",",
"base",
")",
":",
"if",
"length",
"==",
"1",
":",
"# Last digit can be 0 only if length is 1.",
"return",
"[",
"np",
".",
"random",
".",
"randint",
"(",
"base",
")",
"]",
"prefix",
"=",
"[",
"np",
".",
"random",
".",
"randint",
"(",
"base",
")",
"for",
"_",
"in",
"range",
"(",
"length",
"-",
"1",
")",
"]",
"return",
"prefix",
"+",
"[",
"np",
".",
"random",
".",
"randint",
"(",
"base",
"-",
"1",
")",
"+",
"1",
"]"
] |
Helper function: generate a random number as a lower-endian digits list.
|
[
"Helper",
"function",
":",
"generate",
"a",
"random",
"number",
"as",
"a",
"lower",
"-",
"endian",
"digits",
"list",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/algorithmic.py#L323-L328
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/wikisum/parallel_launch.py
|
remote_run
|
def remote_run(cmd, instance_name, detach=False, retries=1):
"""Run command on GCS instance, optionally detached."""
if detach:
cmd = SCREEN.format(command=cmd)
args = SSH.format(instance_name=instance_name).split()
args.append(cmd)
for i in range(retries + 1):
try:
if i > 0:
tf.logging.info("Retry %d for %s", i, args)
return sp.check_call(args)
except sp.CalledProcessError as e:
if i == retries:
raise e
|
python
|
def remote_run(cmd, instance_name, detach=False, retries=1):
"""Run command on GCS instance, optionally detached."""
if detach:
cmd = SCREEN.format(command=cmd)
args = SSH.format(instance_name=instance_name).split()
args.append(cmd)
for i in range(retries + 1):
try:
if i > 0:
tf.logging.info("Retry %d for %s", i, args)
return sp.check_call(args)
except sp.CalledProcessError as e:
if i == retries:
raise e
|
[
"def",
"remote_run",
"(",
"cmd",
",",
"instance_name",
",",
"detach",
"=",
"False",
",",
"retries",
"=",
"1",
")",
":",
"if",
"detach",
":",
"cmd",
"=",
"SCREEN",
".",
"format",
"(",
"command",
"=",
"cmd",
")",
"args",
"=",
"SSH",
".",
"format",
"(",
"instance_name",
"=",
"instance_name",
")",
".",
"split",
"(",
")",
"args",
".",
"append",
"(",
"cmd",
")",
"for",
"i",
"in",
"range",
"(",
"retries",
"+",
"1",
")",
":",
"try",
":",
"if",
"i",
">",
"0",
":",
"tf",
".",
"logging",
".",
"info",
"(",
"\"Retry %d for %s\"",
",",
"i",
",",
"args",
")",
"return",
"sp",
".",
"check_call",
"(",
"args",
")",
"except",
"sp",
".",
"CalledProcessError",
"as",
"e",
":",
"if",
"i",
"==",
"retries",
":",
"raise",
"e"
] |
Run command on GCS instance, optionally detached.
|
[
"Run",
"command",
"on",
"GCS",
"instance",
"optionally",
"detached",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/wikisum/parallel_launch.py#L98-L111
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/wikisum/parallel_launch.py
|
wait_for_ssh
|
def wait_for_ssh(ip):
"""Wait for SSH to be available at given IP address."""
for _ in range(12):
with safe_socket() as s:
try:
s.connect((ip, 22))
return True
except socket.timeout:
pass
time.sleep(10)
return False
|
python
|
def wait_for_ssh(ip):
"""Wait for SSH to be available at given IP address."""
for _ in range(12):
with safe_socket() as s:
try:
s.connect((ip, 22))
return True
except socket.timeout:
pass
time.sleep(10)
return False
|
[
"def",
"wait_for_ssh",
"(",
"ip",
")",
":",
"for",
"_",
"in",
"range",
"(",
"12",
")",
":",
"with",
"safe_socket",
"(",
")",
"as",
"s",
":",
"try",
":",
"s",
".",
"connect",
"(",
"(",
"ip",
",",
"22",
")",
")",
"return",
"True",
"except",
"socket",
".",
"timeout",
":",
"pass",
"time",
".",
"sleep",
"(",
"10",
")",
"return",
"False"
] |
Wait for SSH to be available at given IP address.
|
[
"Wait",
"for",
"SSH",
"to",
"be",
"available",
"at",
"given",
"IP",
"address",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/wikisum/parallel_launch.py#L128-L138
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/data_generators/wikisum/parallel_launch.py
|
launch_instance
|
def launch_instance(instance_name,
command,
existing_ip=None,
cpu=1,
mem=4,
code_dir=None,
setup_command=None):
"""Launch a GCE instance."""
# Create instance
ip = existing_ip or create_instance(instance_name, cpu=cpu, mem=mem)
tf.logging.info("Waiting for SSH %s", instance_name)
ready = wait_for_ssh(ip)
if not ready:
raise ValueError("Instance %s never ready for SSH" % instance_name)
# Copy code
if code_dir:
shell_run_with_retry(COPY_CODE, retries=2,
local_dir=code_dir, instance_name=instance_name)
# Run setup
if setup_command:
tf.logging.info("Running setup on %s", instance_name)
remote_run(setup_command, instance_name)
# Run command
tf.logging.info("Running command on %s", instance_name)
remote_run(command, instance_name, detach=True)
|
python
|
def launch_instance(instance_name,
command,
existing_ip=None,
cpu=1,
mem=4,
code_dir=None,
setup_command=None):
"""Launch a GCE instance."""
# Create instance
ip = existing_ip or create_instance(instance_name, cpu=cpu, mem=mem)
tf.logging.info("Waiting for SSH %s", instance_name)
ready = wait_for_ssh(ip)
if not ready:
raise ValueError("Instance %s never ready for SSH" % instance_name)
# Copy code
if code_dir:
shell_run_with_retry(COPY_CODE, retries=2,
local_dir=code_dir, instance_name=instance_name)
# Run setup
if setup_command:
tf.logging.info("Running setup on %s", instance_name)
remote_run(setup_command, instance_name)
# Run command
tf.logging.info("Running command on %s", instance_name)
remote_run(command, instance_name, detach=True)
|
[
"def",
"launch_instance",
"(",
"instance_name",
",",
"command",
",",
"existing_ip",
"=",
"None",
",",
"cpu",
"=",
"1",
",",
"mem",
"=",
"4",
",",
"code_dir",
"=",
"None",
",",
"setup_command",
"=",
"None",
")",
":",
"# Create instance",
"ip",
"=",
"existing_ip",
"or",
"create_instance",
"(",
"instance_name",
",",
"cpu",
"=",
"cpu",
",",
"mem",
"=",
"mem",
")",
"tf",
".",
"logging",
".",
"info",
"(",
"\"Waiting for SSH %s\"",
",",
"instance_name",
")",
"ready",
"=",
"wait_for_ssh",
"(",
"ip",
")",
"if",
"not",
"ready",
":",
"raise",
"ValueError",
"(",
"\"Instance %s never ready for SSH\"",
"%",
"instance_name",
")",
"# Copy code",
"if",
"code_dir",
":",
"shell_run_with_retry",
"(",
"COPY_CODE",
",",
"retries",
"=",
"2",
",",
"local_dir",
"=",
"code_dir",
",",
"instance_name",
"=",
"instance_name",
")",
"# Run setup",
"if",
"setup_command",
":",
"tf",
".",
"logging",
".",
"info",
"(",
"\"Running setup on %s\"",
",",
"instance_name",
")",
"remote_run",
"(",
"setup_command",
",",
"instance_name",
")",
"# Run command",
"tf",
".",
"logging",
".",
"info",
"(",
"\"Running command on %s\"",
",",
"instance_name",
")",
"remote_run",
"(",
"command",
",",
"instance_name",
",",
"detach",
"=",
"True",
")"
] |
Launch a GCE instance.
|
[
"Launch",
"a",
"GCE",
"instance",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/data_generators/wikisum/parallel_launch.py#L171-L198
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
evolved_transformer_encoder
|
def evolved_transformer_encoder(encoder_input,
encoder_self_attention_bias,
hparams,
name="encoder",
nonpadding=None,
save_weights_to=None,
make_image_summary=True,
losses=None,
attn_bias_for_padding=None):
"""Evolved Transformer encoder. See arxiv.org/abs/1901.11117 for more details.
Note: Pad remover is not supported.
Args:
encoder_input: a Tensor.
encoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
hparams: hyperparameters for model.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This must either be passed in,
which we do for "packed" datasets, or inferred from
encoder_self_attention_bias. The knowledge about padding is used for
pad_remover(efficiency) and to mask out padding in convolutional layers.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not used.
attn_bias_for_padding: Padded attention bias in case a unidirectional
encoder is being used where future attention is masked.
Returns:
Tensor encoder output.
"""
del losses
hidden_state = encoder_input
attention_dropout_broadcast_dims = (
common_layers.comma_separated_string_to_integer_list(
getattr(hparams, "attention_dropout_broadcast_dims", "")))
with tf.variable_scope(name):
if nonpadding is not None:
padding = 1.0 - nonpadding
else:
attention_bias = encoder_self_attention_bias
if attn_bias_for_padding is not None:
attention_bias = attn_bias_for_padding
# Only bfloat16 and float32 supported.
float_type = hparams.get("activation_dtype", "float32")
if float_type == "bfloat16":
cast_fn = tf.to_bfloat16
else:
assert float_type == "float32"
cast_fn = tf.to_float
padding = common_attention.attention_bias_to_padding(
attention_bias, cast_fn)
nonpadding = 1.0 - padding
for layer in range(hparams.num_encoder_layers or hparams.num_hidden_layers):
with tf.variable_scope("layer_%d" % layer):
with tf.variable_scope("gated_linear_unit"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
values = common_layers.layers().Dense(
hparams.hidden_size)(hidden_state)
gates = common_layers.layers().Dense(
hparams.hidden_size, activation=tf.nn.sigmoid)(hidden_state)
hidden_state = values * gates
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("conv_branches"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size])
hidden_state *= mask
left_output_dim = int(hparams.hidden_size * 4)
left_state = common_layers.layers().Dense(
left_output_dim, activation=tf.nn.relu)(hidden_state)
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_output_dim = int(hparams.hidden_size / 2)
right_state = common_layers.layers().Conv1D(
right_output_dim,
3,
padding="SAME",
name="standard_conv_3x1",
activation=tf.nn.relu)(hidden_state)
right_state = tf.nn.dropout(right_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.pad(
right_state,
[[0, 0], [0, 0], [0, left_output_dim - right_output_dim]],
constant_values=0)
hidden_state = left_state + right_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
# Mask padding from conv layer.
mask = tf.tile(tf.expand_dims(nonpadding, 2), [1, 1, left_output_dim])
hidden_state *= mask
separable_conv_9x1 = common_layers.layers().SeparableConv1D(
right_output_dim, 9, padding="SAME", name="separable_conv_9x1")
hidden_state = separable_conv_9x1(hidden_state)
hidden_state = tf.pad(
hidden_state,
[[0, 0], [0, 0], [0, hparams.hidden_size - right_output_dim]],
constant_values=0)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("self_attention"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = common_attention.multihead_attention(
hidden_state,
None,
encoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("dense_layers"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = common_layers.layers().Dense(
int(hparams.hidden_size * 4), activation=tf.nn.relu)(hidden_state)
hidden_state = tf.nn.dropout(hidden_state,
1 - hparams.layer_prepostprocess_dropout)
hidden_state = common_layers.layers().Dense(
hparams.hidden_size)(hidden_state)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
# If normalization is done in layer_preprocess, then it should also be done
# on the output, since the output can grow very large, being the sum of
# a whole stack of unnormalized layer outputs.
return common_layers.layer_preprocess(hidden_state, hparams)
|
python
|
def evolved_transformer_encoder(encoder_input,
encoder_self_attention_bias,
hparams,
name="encoder",
nonpadding=None,
save_weights_to=None,
make_image_summary=True,
losses=None,
attn_bias_for_padding=None):
"""Evolved Transformer encoder. See arxiv.org/abs/1901.11117 for more details.
Note: Pad remover is not supported.
Args:
encoder_input: a Tensor.
encoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
hparams: hyperparameters for model.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This must either be passed in,
which we do for "packed" datasets, or inferred from
encoder_self_attention_bias. The knowledge about padding is used for
pad_remover(efficiency) and to mask out padding in convolutional layers.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not used.
attn_bias_for_padding: Padded attention bias in case a unidirectional
encoder is being used where future attention is masked.
Returns:
Tensor encoder output.
"""
del losses
hidden_state = encoder_input
attention_dropout_broadcast_dims = (
common_layers.comma_separated_string_to_integer_list(
getattr(hparams, "attention_dropout_broadcast_dims", "")))
with tf.variable_scope(name):
if nonpadding is not None:
padding = 1.0 - nonpadding
else:
attention_bias = encoder_self_attention_bias
if attn_bias_for_padding is not None:
attention_bias = attn_bias_for_padding
# Only bfloat16 and float32 supported.
float_type = hparams.get("activation_dtype", "float32")
if float_type == "bfloat16":
cast_fn = tf.to_bfloat16
else:
assert float_type == "float32"
cast_fn = tf.to_float
padding = common_attention.attention_bias_to_padding(
attention_bias, cast_fn)
nonpadding = 1.0 - padding
for layer in range(hparams.num_encoder_layers or hparams.num_hidden_layers):
with tf.variable_scope("layer_%d" % layer):
with tf.variable_scope("gated_linear_unit"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
values = common_layers.layers().Dense(
hparams.hidden_size)(hidden_state)
gates = common_layers.layers().Dense(
hparams.hidden_size, activation=tf.nn.sigmoid)(hidden_state)
hidden_state = values * gates
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("conv_branches"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size])
hidden_state *= mask
left_output_dim = int(hparams.hidden_size * 4)
left_state = common_layers.layers().Dense(
left_output_dim, activation=tf.nn.relu)(hidden_state)
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_output_dim = int(hparams.hidden_size / 2)
right_state = common_layers.layers().Conv1D(
right_output_dim,
3,
padding="SAME",
name="standard_conv_3x1",
activation=tf.nn.relu)(hidden_state)
right_state = tf.nn.dropout(right_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.pad(
right_state,
[[0, 0], [0, 0], [0, left_output_dim - right_output_dim]],
constant_values=0)
hidden_state = left_state + right_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
# Mask padding from conv layer.
mask = tf.tile(tf.expand_dims(nonpadding, 2), [1, 1, left_output_dim])
hidden_state *= mask
separable_conv_9x1 = common_layers.layers().SeparableConv1D(
right_output_dim, 9, padding="SAME", name="separable_conv_9x1")
hidden_state = separable_conv_9x1(hidden_state)
hidden_state = tf.pad(
hidden_state,
[[0, 0], [0, 0], [0, hparams.hidden_size - right_output_dim]],
constant_values=0)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("self_attention"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = common_attention.multihead_attention(
hidden_state,
None,
encoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("dense_layers"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = common_layers.layers().Dense(
int(hparams.hidden_size * 4), activation=tf.nn.relu)(hidden_state)
hidden_state = tf.nn.dropout(hidden_state,
1 - hparams.layer_prepostprocess_dropout)
hidden_state = common_layers.layers().Dense(
hparams.hidden_size)(hidden_state)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
# If normalization is done in layer_preprocess, then it should also be done
# on the output, since the output can grow very large, being the sum of
# a whole stack of unnormalized layer outputs.
return common_layers.layer_preprocess(hidden_state, hparams)
|
[
"def",
"evolved_transformer_encoder",
"(",
"encoder_input",
",",
"encoder_self_attention_bias",
",",
"hparams",
",",
"name",
"=",
"\"encoder\"",
",",
"nonpadding",
"=",
"None",
",",
"save_weights_to",
"=",
"None",
",",
"make_image_summary",
"=",
"True",
",",
"losses",
"=",
"None",
",",
"attn_bias_for_padding",
"=",
"None",
")",
":",
"del",
"losses",
"hidden_state",
"=",
"encoder_input",
"attention_dropout_broadcast_dims",
"=",
"(",
"common_layers",
".",
"comma_separated_string_to_integer_list",
"(",
"getattr",
"(",
"hparams",
",",
"\"attention_dropout_broadcast_dims\"",
",",
"\"\"",
")",
")",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"name",
")",
":",
"if",
"nonpadding",
"is",
"not",
"None",
":",
"padding",
"=",
"1.0",
"-",
"nonpadding",
"else",
":",
"attention_bias",
"=",
"encoder_self_attention_bias",
"if",
"attn_bias_for_padding",
"is",
"not",
"None",
":",
"attention_bias",
"=",
"attn_bias_for_padding",
"# Only bfloat16 and float32 supported.",
"float_type",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
"if",
"float_type",
"==",
"\"bfloat16\"",
":",
"cast_fn",
"=",
"tf",
".",
"to_bfloat16",
"else",
":",
"assert",
"float_type",
"==",
"\"float32\"",
"cast_fn",
"=",
"tf",
".",
"to_float",
"padding",
"=",
"common_attention",
".",
"attention_bias_to_padding",
"(",
"attention_bias",
",",
"cast_fn",
")",
"nonpadding",
"=",
"1.0",
"-",
"padding",
"for",
"layer",
"in",
"range",
"(",
"hparams",
".",
"num_encoder_layers",
"or",
"hparams",
".",
"num_hidden_layers",
")",
":",
"with",
"tf",
".",
"variable_scope",
"(",
"\"layer_%d\"",
"%",
"layer",
")",
":",
"with",
"tf",
".",
"variable_scope",
"(",
"\"gated_linear_unit\"",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"values",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Dense",
"(",
"hparams",
".",
"hidden_size",
")",
"(",
"hidden_state",
")",
"gates",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Dense",
"(",
"hparams",
".",
"hidden_size",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"sigmoid",
")",
"(",
"hidden_state",
")",
"hidden_state",
"=",
"values",
"*",
"gates",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"\"conv_branches\"",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"# Mask padding from conv layers.",
"mask",
"=",
"tf",
".",
"tile",
"(",
"tf",
".",
"expand_dims",
"(",
"nonpadding",
",",
"2",
")",
",",
"[",
"1",
",",
"1",
",",
"hparams",
".",
"hidden_size",
"]",
")",
"hidden_state",
"*=",
"mask",
"left_output_dim",
"=",
"int",
"(",
"hparams",
".",
"hidden_size",
"*",
"4",
")",
"left_state",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Dense",
"(",
"left_output_dim",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"relu",
")",
"(",
"hidden_state",
")",
"left_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"left_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"right_output_dim",
"=",
"int",
"(",
"hparams",
".",
"hidden_size",
"/",
"2",
")",
"right_state",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Conv1D",
"(",
"right_output_dim",
",",
"3",
",",
"padding",
"=",
"\"SAME\"",
",",
"name",
"=",
"\"standard_conv_3x1\"",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"relu",
")",
"(",
"hidden_state",
")",
"right_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"right_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"right_state",
"=",
"tf",
".",
"pad",
"(",
"right_state",
",",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"left_output_dim",
"-",
"right_output_dim",
"]",
"]",
",",
"constant_values",
"=",
"0",
")",
"hidden_state",
"=",
"left_state",
"+",
"right_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"# Mask padding from conv layer.",
"mask",
"=",
"tf",
".",
"tile",
"(",
"tf",
".",
"expand_dims",
"(",
"nonpadding",
",",
"2",
")",
",",
"[",
"1",
",",
"1",
",",
"left_output_dim",
"]",
")",
"hidden_state",
"*=",
"mask",
"separable_conv_9x1",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"SeparableConv1D",
"(",
"right_output_dim",
",",
"9",
",",
"padding",
"=",
"\"SAME\"",
",",
"name",
"=",
"\"separable_conv_9x1\"",
")",
"hidden_state",
"=",
"separable_conv_9x1",
"(",
"hidden_state",
")",
"hidden_state",
"=",
"tf",
".",
"pad",
"(",
"hidden_state",
",",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"hparams",
".",
"hidden_size",
"-",
"right_output_dim",
"]",
"]",
",",
"constant_values",
"=",
"0",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"\"self_attention\"",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"hidden_state",
"=",
"common_attention",
".",
"multihead_attention",
"(",
"hidden_state",
",",
"None",
",",
"encoder_self_attention_bias",
",",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"num_heads",
",",
"hparams",
".",
"attention_dropout",
",",
"attention_type",
"=",
"hparams",
".",
"self_attention_type",
",",
"max_relative_position",
"=",
"hparams",
".",
"max_relative_position",
",",
"heads_share_relative_embedding",
"=",
"(",
"hparams",
".",
"heads_share_relative_embedding",
")",
",",
"add_relative_to_values",
"=",
"hparams",
".",
"add_relative_to_values",
",",
"save_weights_to",
"=",
"save_weights_to",
",",
"make_image_summary",
"=",
"make_image_summary",
",",
"dropout_broadcast_dims",
"=",
"attention_dropout_broadcast_dims",
",",
"max_length",
"=",
"hparams",
".",
"get",
"(",
"\"max_length\"",
")",
",",
"vars_3d",
"=",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
",",
"activation_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
",",
"weight_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"weight_dtype\"",
",",
"\"float32\"",
")",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"\"dense_layers\"",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"hidden_state",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Dense",
"(",
"int",
"(",
"hparams",
".",
"hidden_size",
"*",
"4",
")",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"relu",
")",
"(",
"hidden_state",
")",
"hidden_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"hidden_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"hidden_state",
"=",
"common_layers",
".",
"layers",
"(",
")",
".",
"Dense",
"(",
"hparams",
".",
"hidden_size",
")",
"(",
"hidden_state",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"# If normalization is done in layer_preprocess, then it should also be done",
"# on the output, since the output can grow very large, being the sum of",
"# a whole stack of unnormalized layer outputs.",
"return",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")"
] |
Evolved Transformer encoder. See arxiv.org/abs/1901.11117 for more details.
Note: Pad remover is not supported.
Args:
encoder_input: a Tensor.
encoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
hparams: hyperparameters for model.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This must either be passed in,
which we do for "packed" datasets, or inferred from
encoder_self_attention_bias. The knowledge about padding is used for
pad_remover(efficiency) and to mask out padding in convolutional layers.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not used.
attn_bias_for_padding: Padded attention bias in case a unidirectional
encoder is being used where future attention is masked.
Returns:
Tensor encoder output.
|
[
"Evolved",
"Transformer",
"encoder",
".",
"See",
"arxiv",
".",
"org",
"/",
"abs",
"/",
"1901",
".",
"11117",
"for",
"more",
"details",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L76-L246
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
evolved_transformer_decoder
|
def evolved_transformer_decoder(decoder_input,
encoder_output,
decoder_self_attention_bias,
encoder_decoder_attention_bias,
hparams,
cache=None,
decode_loop_step=None,
name="decoder",
nonpadding=None,
save_weights_to=None,
make_image_summary=True,
losses=None):
"""Evolved Transformer decoder. See arxiv.org/abs/1901.11117 for more details.
Args:
decoder_input: a Tensor.
encoder_output: a Tensor.
decoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
encoder_decoder_attention_bias: bias Tensor for encoder-decoder attention
(see common_attention.attention_bias()).
hparams: hyperparameters for model.
cache: dict, containing tensors which are the results of previous
layers, used for fast decoding.
decode_loop_step: An integer, step number of the decoding loop. Only used
for inference on TPU.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This is used to mask out
padding in convolutional layers. We generally only need this mask for
"packed" datasets, because for ordinary datasets, no padding is ever
followed by nonpadding.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not supported.
Returns:
Decoder output tensor.
"""
del losses
attention_dropout_broadcast_dims = (
common_layers.comma_separated_string_to_integer_list(
getattr(hparams, "attention_dropout_broadcast_dims", "")))
with tf.variable_scope(name):
hidden_state = decoder_input
for layer in range(hparams.num_decoder_layers or hparams.num_hidden_layers):
layer_name = "layer_%d" % layer
layer_cache = cache[layer_name] if cache is not None else None
with tf.variable_scope(layer_name):
with tf.variable_scope(_SIXTEEN_HEAD_ATTENTION_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = layer_cache[
_SIXTEEN_HEAD_ATTENTION_NAME] if layer_cache is not None else None
left_state = common_attention.multihead_attention(
hidden_state,
None,
decoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
_capped_double_heads(hparams.num_heads),
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
decode_loop_step=decode_loop_step,
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
if encoder_output is not None:
with tf.variable_scope(_FIRST_ATTEND_TO_ENCODER_NAME):
attention_cache = (
layer_cache[_FIRST_ATTEND_TO_ENCODER_NAME]
if layer_cache is not None else None)
right_state = common_attention.multihead_attention(
hidden_state,
encoder_output,
encoder_decoder_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.nn.dropout(
right_state, 1 - hparams.layer_prepostprocess_dropout)
hidden_state = residual_state + left_state + right_state
else:
hidden_state = common_layers.layer_postprocess(
residual_state, left_state, hparams)
with tf.variable_scope(_CONV_BRANCHES_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
if nonpadding is not None:
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size])
hidden_state *= mask
if layer_cache:
if decode_loop_step is None:
hidden_state = layer_cache[
_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.concat(
[
layer_cache[_CONV_BRANCHES_FIRST_LAYER_NAME],
hidden_state
],
axis=1)[:, -1 * _DECODER_LEFT_CONV_PADDING - 1:, :]
left_state = hidden_state
right_state = hidden_state[:, _DECODER_LEFT_CONV_PADDING -
_DECODER_RIGHT_CONV_PADDING:, :]
else:
# Inplace update is required for inference on TPU.
# Inplace_ops only supports inplace_update on the first dimension.
tmp = tf.transpose(
layer_cache[_CONV_BRANCHES_FIRST_LAYER_NAME], perm=[1, 0, 2])
tmp = tf.expand_dims(tmp, axis=1)
tmp = inplace_ops.alias_inplace_update(
tmp,
decode_loop_step * tf.shape(hidden_state)[1] +
_DECODER_LEFT_CONV_PADDING,
tf.transpose(hidden_state, perm=[1, 0, 2]))
tmp = tf.squeeze(tmp, axis=1)
hidden_state = layer_cache[
_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.transpose(
tmp, perm=[1, 0, 2])
left_state_indexes = [
decode_loop_step + i
for i in range(_DECODER_LEFT_CONV_PADDING + 1)
]
left_state = tf.gather(hidden_state, left_state_indexes, axis=1)
right_state_indexes = [
decode_loop_step + i +
(_DECODER_LEFT_CONV_PADDING - _DECODER_RIGHT_CONV_PADDING)
for i in range(_DECODER_RIGHT_CONV_PADDING + 1)
]
right_state = tf.gather(hidden_state, right_state_indexes, axis=1)
else: # No caching.
left_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_LEFT_CONV_PADDING, 0], [0, 0]])
right_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_RIGHT_CONV_PADDING, 0], [0, 0]])
left_output_dim = int(hparams.hidden_size * 2)
separable_conv_11x1 = tf.layers.SeparableConv1D(
left_output_dim,
11,
padding="VALID",
name="separable_conv11x1",
activation=tf.nn.relu)
left_state = separable_conv_11x1.apply(left_state)
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_output_dim = int(hparams.hidden_size / 2)
separable_conv_7x1_1 = tf.layers.SeparableConv1D(
right_output_dim, 7, padding="VALID", name="separable_conv_7x1_1")
right_state = separable_conv_7x1_1.apply(right_state)
right_state = tf.nn.dropout(right_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.pad(
right_state,
[[0, 0], [0, 0], [0, left_output_dim - right_output_dim]],
constant_values=0)
hidden_state = left_state + right_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
if nonpadding is not None:
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size * 2])
hidden_state *= mask
if layer_cache:
if decode_loop_step is None:
hidden_state = layer_cache[
_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.concat(
[
layer_cache[_CONV_BRANCHES_SECOND_LAYER_NAME],
hidden_state
],
axis=1)[:, -1 * _DECODER_FINAL_CONV_PADDING - 1:, :]
else:
# Inplace update is required for inference on TPU.
# Inplace_ops only supports inplace_update on the first dimension.
tmp = tf.transpose(
layer_cache[_CONV_BRANCHES_SECOND_LAYER_NAME], perm=[1, 0, 2])
tmp = tf.expand_dims(tmp, axis=1)
tmp = inplace_ops.alias_inplace_update(
tmp, (decode_loop_step + _DECODER_FINAL_CONV_PADDING) *
tf.shape(hidden_state)[1],
tf.transpose(hidden_state, perm=[1, 0, 2]))
tmp = tf.squeeze(tmp, axis=1)
hidden_state = layer_cache[
_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.transpose(
tmp, perm=[1, 0, 2])
hidden_state_indexes = [
decode_loop_step + i
for i in range(_DECODER_FINAL_CONV_PADDING + 1)
]
hidden_state = tf.gather(
hidden_state, hidden_state_indexes, axis=1)
else:
hidden_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_FINAL_CONV_PADDING, 0], [0, 0]])
separable_conv_7x1_2 = tf.layers.SeparableConv1D(
hparams.hidden_size,
7,
padding="VALID",
name="separable_conv_7x1_2")
hidden_state = separable_conv_7x1_2.apply(hidden_state)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope(_VANILLA_ATTENTION_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = layer_cache[
_VANILLA_ATTENTION_NAME] if layer_cache is not None else None
hidden_state = common_attention.multihead_attention(
hidden_state,
None,
decoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
decode_loop_step=decode_loop_step,
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
if encoder_output is not None:
with tf.variable_scope(_SECOND_ATTEND_TO_ENCODER_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = (
layer_cache[_SECOND_ATTEND_TO_ENCODER_NAME]
if layer_cache is not None else None)
hidden_state = common_attention.multihead_attention(
hidden_state,
encoder_output,
encoder_decoder_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("dense_layers"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = tf.layers.dense(
hidden_state,
int(hparams.hidden_size * 4),
activation=tf.nn.swish)
hidden_state = tf.nn.dropout(hidden_state,
1 - hparams.layer_prepostprocess_dropout)
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = tf.layers.dense(hidden_state, hparams.hidden_size)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
return common_layers.layer_preprocess(hidden_state, hparams)
|
python
|
def evolved_transformer_decoder(decoder_input,
encoder_output,
decoder_self_attention_bias,
encoder_decoder_attention_bias,
hparams,
cache=None,
decode_loop_step=None,
name="decoder",
nonpadding=None,
save_weights_to=None,
make_image_summary=True,
losses=None):
"""Evolved Transformer decoder. See arxiv.org/abs/1901.11117 for more details.
Args:
decoder_input: a Tensor.
encoder_output: a Tensor.
decoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
encoder_decoder_attention_bias: bias Tensor for encoder-decoder attention
(see common_attention.attention_bias()).
hparams: hyperparameters for model.
cache: dict, containing tensors which are the results of previous
layers, used for fast decoding.
decode_loop_step: An integer, step number of the decoding loop. Only used
for inference on TPU.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This is used to mask out
padding in convolutional layers. We generally only need this mask for
"packed" datasets, because for ordinary datasets, no padding is ever
followed by nonpadding.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not supported.
Returns:
Decoder output tensor.
"""
del losses
attention_dropout_broadcast_dims = (
common_layers.comma_separated_string_to_integer_list(
getattr(hparams, "attention_dropout_broadcast_dims", "")))
with tf.variable_scope(name):
hidden_state = decoder_input
for layer in range(hparams.num_decoder_layers or hparams.num_hidden_layers):
layer_name = "layer_%d" % layer
layer_cache = cache[layer_name] if cache is not None else None
with tf.variable_scope(layer_name):
with tf.variable_scope(_SIXTEEN_HEAD_ATTENTION_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = layer_cache[
_SIXTEEN_HEAD_ATTENTION_NAME] if layer_cache is not None else None
left_state = common_attention.multihead_attention(
hidden_state,
None,
decoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
_capped_double_heads(hparams.num_heads),
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
decode_loop_step=decode_loop_step,
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
if encoder_output is not None:
with tf.variable_scope(_FIRST_ATTEND_TO_ENCODER_NAME):
attention_cache = (
layer_cache[_FIRST_ATTEND_TO_ENCODER_NAME]
if layer_cache is not None else None)
right_state = common_attention.multihead_attention(
hidden_state,
encoder_output,
encoder_decoder_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.nn.dropout(
right_state, 1 - hparams.layer_prepostprocess_dropout)
hidden_state = residual_state + left_state + right_state
else:
hidden_state = common_layers.layer_postprocess(
residual_state, left_state, hparams)
with tf.variable_scope(_CONV_BRANCHES_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
if nonpadding is not None:
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size])
hidden_state *= mask
if layer_cache:
if decode_loop_step is None:
hidden_state = layer_cache[
_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.concat(
[
layer_cache[_CONV_BRANCHES_FIRST_LAYER_NAME],
hidden_state
],
axis=1)[:, -1 * _DECODER_LEFT_CONV_PADDING - 1:, :]
left_state = hidden_state
right_state = hidden_state[:, _DECODER_LEFT_CONV_PADDING -
_DECODER_RIGHT_CONV_PADDING:, :]
else:
# Inplace update is required for inference on TPU.
# Inplace_ops only supports inplace_update on the first dimension.
tmp = tf.transpose(
layer_cache[_CONV_BRANCHES_FIRST_LAYER_NAME], perm=[1, 0, 2])
tmp = tf.expand_dims(tmp, axis=1)
tmp = inplace_ops.alias_inplace_update(
tmp,
decode_loop_step * tf.shape(hidden_state)[1] +
_DECODER_LEFT_CONV_PADDING,
tf.transpose(hidden_state, perm=[1, 0, 2]))
tmp = tf.squeeze(tmp, axis=1)
hidden_state = layer_cache[
_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.transpose(
tmp, perm=[1, 0, 2])
left_state_indexes = [
decode_loop_step + i
for i in range(_DECODER_LEFT_CONV_PADDING + 1)
]
left_state = tf.gather(hidden_state, left_state_indexes, axis=1)
right_state_indexes = [
decode_loop_step + i +
(_DECODER_LEFT_CONV_PADDING - _DECODER_RIGHT_CONV_PADDING)
for i in range(_DECODER_RIGHT_CONV_PADDING + 1)
]
right_state = tf.gather(hidden_state, right_state_indexes, axis=1)
else: # No caching.
left_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_LEFT_CONV_PADDING, 0], [0, 0]])
right_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_RIGHT_CONV_PADDING, 0], [0, 0]])
left_output_dim = int(hparams.hidden_size * 2)
separable_conv_11x1 = tf.layers.SeparableConv1D(
left_output_dim,
11,
padding="VALID",
name="separable_conv11x1",
activation=tf.nn.relu)
left_state = separable_conv_11x1.apply(left_state)
left_state = tf.nn.dropout(left_state,
1 - hparams.layer_prepostprocess_dropout)
right_output_dim = int(hparams.hidden_size / 2)
separable_conv_7x1_1 = tf.layers.SeparableConv1D(
right_output_dim, 7, padding="VALID", name="separable_conv_7x1_1")
right_state = separable_conv_7x1_1.apply(right_state)
right_state = tf.nn.dropout(right_state,
1 - hparams.layer_prepostprocess_dropout)
right_state = tf.pad(
right_state,
[[0, 0], [0, 0], [0, left_output_dim - right_output_dim]],
constant_values=0)
hidden_state = left_state + right_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
if nonpadding is not None:
# Mask padding from conv layers.
mask = tf.tile(
tf.expand_dims(nonpadding, 2), [1, 1, hparams.hidden_size * 2])
hidden_state *= mask
if layer_cache:
if decode_loop_step is None:
hidden_state = layer_cache[
_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.concat(
[
layer_cache[_CONV_BRANCHES_SECOND_LAYER_NAME],
hidden_state
],
axis=1)[:, -1 * _DECODER_FINAL_CONV_PADDING - 1:, :]
else:
# Inplace update is required for inference on TPU.
# Inplace_ops only supports inplace_update on the first dimension.
tmp = tf.transpose(
layer_cache[_CONV_BRANCHES_SECOND_LAYER_NAME], perm=[1, 0, 2])
tmp = tf.expand_dims(tmp, axis=1)
tmp = inplace_ops.alias_inplace_update(
tmp, (decode_loop_step + _DECODER_FINAL_CONV_PADDING) *
tf.shape(hidden_state)[1],
tf.transpose(hidden_state, perm=[1, 0, 2]))
tmp = tf.squeeze(tmp, axis=1)
hidden_state = layer_cache[
_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.transpose(
tmp, perm=[1, 0, 2])
hidden_state_indexes = [
decode_loop_step + i
for i in range(_DECODER_FINAL_CONV_PADDING + 1)
]
hidden_state = tf.gather(
hidden_state, hidden_state_indexes, axis=1)
else:
hidden_state = tf.pad(
hidden_state,
paddings=[[0, 0], [_DECODER_FINAL_CONV_PADDING, 0], [0, 0]])
separable_conv_7x1_2 = tf.layers.SeparableConv1D(
hparams.hidden_size,
7,
padding="VALID",
name="separable_conv_7x1_2")
hidden_state = separable_conv_7x1_2.apply(hidden_state)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope(_VANILLA_ATTENTION_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = layer_cache[
_VANILLA_ATTENTION_NAME] if layer_cache is not None else None
hidden_state = common_attention.multihead_attention(
hidden_state,
None,
decoder_self_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
attention_type=hparams.self_attention_type,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
decode_loop_step=decode_loop_step,
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
if encoder_output is not None:
with tf.variable_scope(_SECOND_ATTEND_TO_ENCODER_NAME):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
attention_cache = (
layer_cache[_SECOND_ATTEND_TO_ENCODER_NAME]
if layer_cache is not None else None)
hidden_state = common_attention.multihead_attention(
hidden_state,
encoder_output,
encoder_decoder_attention_bias,
hparams.attention_key_channels or hparams.hidden_size,
hparams.attention_value_channels or hparams.hidden_size,
hparams.hidden_size,
hparams.num_heads,
hparams.attention_dropout,
max_relative_position=hparams.max_relative_position,
heads_share_relative_embedding=(
hparams.heads_share_relative_embedding),
add_relative_to_values=hparams.add_relative_to_values,
save_weights_to=save_weights_to,
cache=attention_cache,
make_image_summary=make_image_summary,
dropout_broadcast_dims=attention_dropout_broadcast_dims,
max_length=hparams.get("max_length"),
vars_3d=hparams.get("attention_variables_3d"),
activation_dtype=hparams.get("activation_dtype", "float32"),
weight_dtype=hparams.get("weight_dtype", "float32"))
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
with tf.variable_scope("dense_layers"):
residual_state = hidden_state
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = tf.layers.dense(
hidden_state,
int(hparams.hidden_size * 4),
activation=tf.nn.swish)
hidden_state = tf.nn.dropout(hidden_state,
1 - hparams.layer_prepostprocess_dropout)
hidden_state = common_layers.layer_preprocess(hidden_state, hparams)
hidden_state = tf.layers.dense(hidden_state, hparams.hidden_size)
hidden_state = common_layers.layer_postprocess(
residual_state, hidden_state, hparams)
return common_layers.layer_preprocess(hidden_state, hparams)
|
[
"def",
"evolved_transformer_decoder",
"(",
"decoder_input",
",",
"encoder_output",
",",
"decoder_self_attention_bias",
",",
"encoder_decoder_attention_bias",
",",
"hparams",
",",
"cache",
"=",
"None",
",",
"decode_loop_step",
"=",
"None",
",",
"name",
"=",
"\"decoder\"",
",",
"nonpadding",
"=",
"None",
",",
"save_weights_to",
"=",
"None",
",",
"make_image_summary",
"=",
"True",
",",
"losses",
"=",
"None",
")",
":",
"del",
"losses",
"attention_dropout_broadcast_dims",
"=",
"(",
"common_layers",
".",
"comma_separated_string_to_integer_list",
"(",
"getattr",
"(",
"hparams",
",",
"\"attention_dropout_broadcast_dims\"",
",",
"\"\"",
")",
")",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"name",
")",
":",
"hidden_state",
"=",
"decoder_input",
"for",
"layer",
"in",
"range",
"(",
"hparams",
".",
"num_decoder_layers",
"or",
"hparams",
".",
"num_hidden_layers",
")",
":",
"layer_name",
"=",
"\"layer_%d\"",
"%",
"layer",
"layer_cache",
"=",
"cache",
"[",
"layer_name",
"]",
"if",
"cache",
"is",
"not",
"None",
"else",
"None",
"with",
"tf",
".",
"variable_scope",
"(",
"layer_name",
")",
":",
"with",
"tf",
".",
"variable_scope",
"(",
"_SIXTEEN_HEAD_ATTENTION_NAME",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"attention_cache",
"=",
"layer_cache",
"[",
"_SIXTEEN_HEAD_ATTENTION_NAME",
"]",
"if",
"layer_cache",
"is",
"not",
"None",
"else",
"None",
"left_state",
"=",
"common_attention",
".",
"multihead_attention",
"(",
"hidden_state",
",",
"None",
",",
"decoder_self_attention_bias",
",",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"hidden_size",
",",
"_capped_double_heads",
"(",
"hparams",
".",
"num_heads",
")",
",",
"hparams",
".",
"attention_dropout",
",",
"attention_type",
"=",
"hparams",
".",
"self_attention_type",
",",
"max_relative_position",
"=",
"hparams",
".",
"max_relative_position",
",",
"heads_share_relative_embedding",
"=",
"(",
"hparams",
".",
"heads_share_relative_embedding",
")",
",",
"add_relative_to_values",
"=",
"hparams",
".",
"add_relative_to_values",
",",
"save_weights_to",
"=",
"save_weights_to",
",",
"cache",
"=",
"attention_cache",
",",
"make_image_summary",
"=",
"make_image_summary",
",",
"dropout_broadcast_dims",
"=",
"attention_dropout_broadcast_dims",
",",
"max_length",
"=",
"hparams",
".",
"get",
"(",
"\"max_length\"",
")",
",",
"decode_loop_step",
"=",
"decode_loop_step",
",",
"vars_3d",
"=",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
",",
"activation_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
",",
"weight_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"weight_dtype\"",
",",
"\"float32\"",
")",
")",
"if",
"encoder_output",
"is",
"not",
"None",
":",
"with",
"tf",
".",
"variable_scope",
"(",
"_FIRST_ATTEND_TO_ENCODER_NAME",
")",
":",
"attention_cache",
"=",
"(",
"layer_cache",
"[",
"_FIRST_ATTEND_TO_ENCODER_NAME",
"]",
"if",
"layer_cache",
"is",
"not",
"None",
"else",
"None",
")",
"right_state",
"=",
"common_attention",
".",
"multihead_attention",
"(",
"hidden_state",
",",
"encoder_output",
",",
"encoder_decoder_attention_bias",
",",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"num_heads",
",",
"hparams",
".",
"attention_dropout",
",",
"max_relative_position",
"=",
"hparams",
".",
"max_relative_position",
",",
"heads_share_relative_embedding",
"=",
"(",
"hparams",
".",
"heads_share_relative_embedding",
")",
",",
"add_relative_to_values",
"=",
"hparams",
".",
"add_relative_to_values",
",",
"save_weights_to",
"=",
"save_weights_to",
",",
"cache",
"=",
"attention_cache",
",",
"make_image_summary",
"=",
"make_image_summary",
",",
"dropout_broadcast_dims",
"=",
"attention_dropout_broadcast_dims",
",",
"max_length",
"=",
"hparams",
".",
"get",
"(",
"\"max_length\"",
")",
",",
"vars_3d",
"=",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
",",
"activation_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
",",
"weight_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"weight_dtype\"",
",",
"\"float32\"",
")",
")",
"left_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"left_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"right_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"right_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"hidden_state",
"=",
"residual_state",
"+",
"left_state",
"+",
"right_state",
"else",
":",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"left_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"_CONV_BRANCHES_NAME",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"if",
"nonpadding",
"is",
"not",
"None",
":",
"# Mask padding from conv layers.",
"mask",
"=",
"tf",
".",
"tile",
"(",
"tf",
".",
"expand_dims",
"(",
"nonpadding",
",",
"2",
")",
",",
"[",
"1",
",",
"1",
",",
"hparams",
".",
"hidden_size",
"]",
")",
"hidden_state",
"*=",
"mask",
"if",
"layer_cache",
":",
"if",
"decode_loop_step",
"is",
"None",
":",
"hidden_state",
"=",
"layer_cache",
"[",
"_CONV_BRANCHES_FIRST_LAYER_NAME",
"]",
"=",
"tf",
".",
"concat",
"(",
"[",
"layer_cache",
"[",
"_CONV_BRANCHES_FIRST_LAYER_NAME",
"]",
",",
"hidden_state",
"]",
",",
"axis",
"=",
"1",
")",
"[",
":",
",",
"-",
"1",
"*",
"_DECODER_LEFT_CONV_PADDING",
"-",
"1",
":",
",",
":",
"]",
"left_state",
"=",
"hidden_state",
"right_state",
"=",
"hidden_state",
"[",
":",
",",
"_DECODER_LEFT_CONV_PADDING",
"-",
"_DECODER_RIGHT_CONV_PADDING",
":",
",",
":",
"]",
"else",
":",
"# Inplace update is required for inference on TPU.",
"# Inplace_ops only supports inplace_update on the first dimension.",
"tmp",
"=",
"tf",
".",
"transpose",
"(",
"layer_cache",
"[",
"_CONV_BRANCHES_FIRST_LAYER_NAME",
"]",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
"tmp",
"=",
"tf",
".",
"expand_dims",
"(",
"tmp",
",",
"axis",
"=",
"1",
")",
"tmp",
"=",
"inplace_ops",
".",
"alias_inplace_update",
"(",
"tmp",
",",
"decode_loop_step",
"*",
"tf",
".",
"shape",
"(",
"hidden_state",
")",
"[",
"1",
"]",
"+",
"_DECODER_LEFT_CONV_PADDING",
",",
"tf",
".",
"transpose",
"(",
"hidden_state",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
")",
"tmp",
"=",
"tf",
".",
"squeeze",
"(",
"tmp",
",",
"axis",
"=",
"1",
")",
"hidden_state",
"=",
"layer_cache",
"[",
"_CONV_BRANCHES_FIRST_LAYER_NAME",
"]",
"=",
"tf",
".",
"transpose",
"(",
"tmp",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
"left_state_indexes",
"=",
"[",
"decode_loop_step",
"+",
"i",
"for",
"i",
"in",
"range",
"(",
"_DECODER_LEFT_CONV_PADDING",
"+",
"1",
")",
"]",
"left_state",
"=",
"tf",
".",
"gather",
"(",
"hidden_state",
",",
"left_state_indexes",
",",
"axis",
"=",
"1",
")",
"right_state_indexes",
"=",
"[",
"decode_loop_step",
"+",
"i",
"+",
"(",
"_DECODER_LEFT_CONV_PADDING",
"-",
"_DECODER_RIGHT_CONV_PADDING",
")",
"for",
"i",
"in",
"range",
"(",
"_DECODER_RIGHT_CONV_PADDING",
"+",
"1",
")",
"]",
"right_state",
"=",
"tf",
".",
"gather",
"(",
"hidden_state",
",",
"right_state_indexes",
",",
"axis",
"=",
"1",
")",
"else",
":",
"# No caching.",
"left_state",
"=",
"tf",
".",
"pad",
"(",
"hidden_state",
",",
"paddings",
"=",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"_DECODER_LEFT_CONV_PADDING",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
"]",
")",
"right_state",
"=",
"tf",
".",
"pad",
"(",
"hidden_state",
",",
"paddings",
"=",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"_DECODER_RIGHT_CONV_PADDING",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
"]",
")",
"left_output_dim",
"=",
"int",
"(",
"hparams",
".",
"hidden_size",
"*",
"2",
")",
"separable_conv_11x1",
"=",
"tf",
".",
"layers",
".",
"SeparableConv1D",
"(",
"left_output_dim",
",",
"11",
",",
"padding",
"=",
"\"VALID\"",
",",
"name",
"=",
"\"separable_conv11x1\"",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"relu",
")",
"left_state",
"=",
"separable_conv_11x1",
".",
"apply",
"(",
"left_state",
")",
"left_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"left_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"right_output_dim",
"=",
"int",
"(",
"hparams",
".",
"hidden_size",
"/",
"2",
")",
"separable_conv_7x1_1",
"=",
"tf",
".",
"layers",
".",
"SeparableConv1D",
"(",
"right_output_dim",
",",
"7",
",",
"padding",
"=",
"\"VALID\"",
",",
"name",
"=",
"\"separable_conv_7x1_1\"",
")",
"right_state",
"=",
"separable_conv_7x1_1",
".",
"apply",
"(",
"right_state",
")",
"right_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"right_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"right_state",
"=",
"tf",
".",
"pad",
"(",
"right_state",
",",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
",",
"[",
"0",
",",
"left_output_dim",
"-",
"right_output_dim",
"]",
"]",
",",
"constant_values",
"=",
"0",
")",
"hidden_state",
"=",
"left_state",
"+",
"right_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"if",
"nonpadding",
"is",
"not",
"None",
":",
"# Mask padding from conv layers.",
"mask",
"=",
"tf",
".",
"tile",
"(",
"tf",
".",
"expand_dims",
"(",
"nonpadding",
",",
"2",
")",
",",
"[",
"1",
",",
"1",
",",
"hparams",
".",
"hidden_size",
"*",
"2",
"]",
")",
"hidden_state",
"*=",
"mask",
"if",
"layer_cache",
":",
"if",
"decode_loop_step",
"is",
"None",
":",
"hidden_state",
"=",
"layer_cache",
"[",
"_CONV_BRANCHES_SECOND_LAYER_NAME",
"]",
"=",
"tf",
".",
"concat",
"(",
"[",
"layer_cache",
"[",
"_CONV_BRANCHES_SECOND_LAYER_NAME",
"]",
",",
"hidden_state",
"]",
",",
"axis",
"=",
"1",
")",
"[",
":",
",",
"-",
"1",
"*",
"_DECODER_FINAL_CONV_PADDING",
"-",
"1",
":",
",",
":",
"]",
"else",
":",
"# Inplace update is required for inference on TPU.",
"# Inplace_ops only supports inplace_update on the first dimension.",
"tmp",
"=",
"tf",
".",
"transpose",
"(",
"layer_cache",
"[",
"_CONV_BRANCHES_SECOND_LAYER_NAME",
"]",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
"tmp",
"=",
"tf",
".",
"expand_dims",
"(",
"tmp",
",",
"axis",
"=",
"1",
")",
"tmp",
"=",
"inplace_ops",
".",
"alias_inplace_update",
"(",
"tmp",
",",
"(",
"decode_loop_step",
"+",
"_DECODER_FINAL_CONV_PADDING",
")",
"*",
"tf",
".",
"shape",
"(",
"hidden_state",
")",
"[",
"1",
"]",
",",
"tf",
".",
"transpose",
"(",
"hidden_state",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
")",
"tmp",
"=",
"tf",
".",
"squeeze",
"(",
"tmp",
",",
"axis",
"=",
"1",
")",
"hidden_state",
"=",
"layer_cache",
"[",
"_CONV_BRANCHES_SECOND_LAYER_NAME",
"]",
"=",
"tf",
".",
"transpose",
"(",
"tmp",
",",
"perm",
"=",
"[",
"1",
",",
"0",
",",
"2",
"]",
")",
"hidden_state_indexes",
"=",
"[",
"decode_loop_step",
"+",
"i",
"for",
"i",
"in",
"range",
"(",
"_DECODER_FINAL_CONV_PADDING",
"+",
"1",
")",
"]",
"hidden_state",
"=",
"tf",
".",
"gather",
"(",
"hidden_state",
",",
"hidden_state_indexes",
",",
"axis",
"=",
"1",
")",
"else",
":",
"hidden_state",
"=",
"tf",
".",
"pad",
"(",
"hidden_state",
",",
"paddings",
"=",
"[",
"[",
"0",
",",
"0",
"]",
",",
"[",
"_DECODER_FINAL_CONV_PADDING",
",",
"0",
"]",
",",
"[",
"0",
",",
"0",
"]",
"]",
")",
"separable_conv_7x1_2",
"=",
"tf",
".",
"layers",
".",
"SeparableConv1D",
"(",
"hparams",
".",
"hidden_size",
",",
"7",
",",
"padding",
"=",
"\"VALID\"",
",",
"name",
"=",
"\"separable_conv_7x1_2\"",
")",
"hidden_state",
"=",
"separable_conv_7x1_2",
".",
"apply",
"(",
"hidden_state",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"_VANILLA_ATTENTION_NAME",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"attention_cache",
"=",
"layer_cache",
"[",
"_VANILLA_ATTENTION_NAME",
"]",
"if",
"layer_cache",
"is",
"not",
"None",
"else",
"None",
"hidden_state",
"=",
"common_attention",
".",
"multihead_attention",
"(",
"hidden_state",
",",
"None",
",",
"decoder_self_attention_bias",
",",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"num_heads",
",",
"hparams",
".",
"attention_dropout",
",",
"attention_type",
"=",
"hparams",
".",
"self_attention_type",
",",
"max_relative_position",
"=",
"hparams",
".",
"max_relative_position",
",",
"heads_share_relative_embedding",
"=",
"(",
"hparams",
".",
"heads_share_relative_embedding",
")",
",",
"add_relative_to_values",
"=",
"hparams",
".",
"add_relative_to_values",
",",
"save_weights_to",
"=",
"save_weights_to",
",",
"cache",
"=",
"attention_cache",
",",
"make_image_summary",
"=",
"make_image_summary",
",",
"dropout_broadcast_dims",
"=",
"attention_dropout_broadcast_dims",
",",
"max_length",
"=",
"hparams",
".",
"get",
"(",
"\"max_length\"",
")",
",",
"decode_loop_step",
"=",
"decode_loop_step",
",",
"vars_3d",
"=",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
",",
"activation_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
",",
"weight_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"weight_dtype\"",
",",
"\"float32\"",
")",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"if",
"encoder_output",
"is",
"not",
"None",
":",
"with",
"tf",
".",
"variable_scope",
"(",
"_SECOND_ATTEND_TO_ENCODER_NAME",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"attention_cache",
"=",
"(",
"layer_cache",
"[",
"_SECOND_ATTEND_TO_ENCODER_NAME",
"]",
"if",
"layer_cache",
"is",
"not",
"None",
"else",
"None",
")",
"hidden_state",
"=",
"common_attention",
".",
"multihead_attention",
"(",
"hidden_state",
",",
"encoder_output",
",",
"encoder_decoder_attention_bias",
",",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"hidden_size",
",",
"hparams",
".",
"num_heads",
",",
"hparams",
".",
"attention_dropout",
",",
"max_relative_position",
"=",
"hparams",
".",
"max_relative_position",
",",
"heads_share_relative_embedding",
"=",
"(",
"hparams",
".",
"heads_share_relative_embedding",
")",
",",
"add_relative_to_values",
"=",
"hparams",
".",
"add_relative_to_values",
",",
"save_weights_to",
"=",
"save_weights_to",
",",
"cache",
"=",
"attention_cache",
",",
"make_image_summary",
"=",
"make_image_summary",
",",
"dropout_broadcast_dims",
"=",
"attention_dropout_broadcast_dims",
",",
"max_length",
"=",
"hparams",
".",
"get",
"(",
"\"max_length\"",
")",
",",
"vars_3d",
"=",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
",",
"activation_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"activation_dtype\"",
",",
"\"float32\"",
")",
",",
"weight_dtype",
"=",
"hparams",
".",
"get",
"(",
"\"weight_dtype\"",
",",
"\"float32\"",
")",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"with",
"tf",
".",
"variable_scope",
"(",
"\"dense_layers\"",
")",
":",
"residual_state",
"=",
"hidden_state",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"hidden_state",
"=",
"tf",
".",
"layers",
".",
"dense",
"(",
"hidden_state",
",",
"int",
"(",
"hparams",
".",
"hidden_size",
"*",
"4",
")",
",",
"activation",
"=",
"tf",
".",
"nn",
".",
"swish",
")",
"hidden_state",
"=",
"tf",
".",
"nn",
".",
"dropout",
"(",
"hidden_state",
",",
"1",
"-",
"hparams",
".",
"layer_prepostprocess_dropout",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")",
"hidden_state",
"=",
"tf",
".",
"layers",
".",
"dense",
"(",
"hidden_state",
",",
"hparams",
".",
"hidden_size",
")",
"hidden_state",
"=",
"common_layers",
".",
"layer_postprocess",
"(",
"residual_state",
",",
"hidden_state",
",",
"hparams",
")",
"return",
"common_layers",
".",
"layer_preprocess",
"(",
"hidden_state",
",",
"hparams",
")"
] |
Evolved Transformer decoder. See arxiv.org/abs/1901.11117 for more details.
Args:
decoder_input: a Tensor.
encoder_output: a Tensor.
decoder_self_attention_bias: bias Tensor for self-attention (see
common_attention.attention_bias()).
encoder_decoder_attention_bias: bias Tensor for encoder-decoder attention
(see common_attention.attention_bias()).
hparams: hyperparameters for model.
cache: dict, containing tensors which are the results of previous
layers, used for fast decoding.
decode_loop_step: An integer, step number of the decoding loop. Only used
for inference on TPU.
name: a string.
nonpadding: optional Tensor with shape [batch_size, encoder_length]
indicating what positions are not padding. This is used to mask out
padding in convolutional layers. We generally only need this mask for
"packed" datasets, because for ordinary datasets, no padding is ever
followed by nonpadding.
save_weights_to: an optional dictionary to capture attention weights for
visualization; the weights tensor will be appended there under a string
key created from the variable scope (including name).
make_image_summary: Whether to make an attention image summary.
losses: Not supported.
Returns:
Decoder output tensor.
|
[
"Evolved",
"Transformer",
"decoder",
".",
"See",
"arxiv",
".",
"org",
"/",
"abs",
"/",
"1901",
".",
"11117",
"for",
"more",
"details",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L249-L589
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
_add_attend_to_encoder_cache
|
def _add_attend_to_encoder_cache(cache, attention_name, hparams, num_layers,
key_channels, value_channels,
vars_3d_num_heads, scope_prefix,
encoder_output):
"""Add attend-to-encoder layers to cache."""
for layer in range(num_layers):
layer_name = "layer_%d" % layer
with tf.variable_scope("%sdecoder/%s/%s/multihead_attention" %
(scope_prefix, layer_name, attention_name)):
k_encdec = common_attention.compute_attention_component(
encoder_output,
key_channels,
name="k",
vars_3d_num_heads=vars_3d_num_heads)
k_encdec = common_attention.split_heads(k_encdec, hparams.num_heads)
v_encdec = common_attention.compute_attention_component(
encoder_output,
value_channels,
name="v",
vars_3d_num_heads=vars_3d_num_heads)
v_encdec = common_attention.split_heads(v_encdec, hparams.num_heads)
cache[layer_name][attention_name] = {
"k_encdec": k_encdec,
"v_encdec": v_encdec
}
return cache
|
python
|
def _add_attend_to_encoder_cache(cache, attention_name, hparams, num_layers,
key_channels, value_channels,
vars_3d_num_heads, scope_prefix,
encoder_output):
"""Add attend-to-encoder layers to cache."""
for layer in range(num_layers):
layer_name = "layer_%d" % layer
with tf.variable_scope("%sdecoder/%s/%s/multihead_attention" %
(scope_prefix, layer_name, attention_name)):
k_encdec = common_attention.compute_attention_component(
encoder_output,
key_channels,
name="k",
vars_3d_num_heads=vars_3d_num_heads)
k_encdec = common_attention.split_heads(k_encdec, hparams.num_heads)
v_encdec = common_attention.compute_attention_component(
encoder_output,
value_channels,
name="v",
vars_3d_num_heads=vars_3d_num_heads)
v_encdec = common_attention.split_heads(v_encdec, hparams.num_heads)
cache[layer_name][attention_name] = {
"k_encdec": k_encdec,
"v_encdec": v_encdec
}
return cache
|
[
"def",
"_add_attend_to_encoder_cache",
"(",
"cache",
",",
"attention_name",
",",
"hparams",
",",
"num_layers",
",",
"key_channels",
",",
"value_channels",
",",
"vars_3d_num_heads",
",",
"scope_prefix",
",",
"encoder_output",
")",
":",
"for",
"layer",
"in",
"range",
"(",
"num_layers",
")",
":",
"layer_name",
"=",
"\"layer_%d\"",
"%",
"layer",
"with",
"tf",
".",
"variable_scope",
"(",
"\"%sdecoder/%s/%s/multihead_attention\"",
"%",
"(",
"scope_prefix",
",",
"layer_name",
",",
"attention_name",
")",
")",
":",
"k_encdec",
"=",
"common_attention",
".",
"compute_attention_component",
"(",
"encoder_output",
",",
"key_channels",
",",
"name",
"=",
"\"k\"",
",",
"vars_3d_num_heads",
"=",
"vars_3d_num_heads",
")",
"k_encdec",
"=",
"common_attention",
".",
"split_heads",
"(",
"k_encdec",
",",
"hparams",
".",
"num_heads",
")",
"v_encdec",
"=",
"common_attention",
".",
"compute_attention_component",
"(",
"encoder_output",
",",
"value_channels",
",",
"name",
"=",
"\"v\"",
",",
"vars_3d_num_heads",
"=",
"vars_3d_num_heads",
")",
"v_encdec",
"=",
"common_attention",
".",
"split_heads",
"(",
"v_encdec",
",",
"hparams",
".",
"num_heads",
")",
"cache",
"[",
"layer_name",
"]",
"[",
"attention_name",
"]",
"=",
"{",
"\"k_encdec\"",
":",
"k_encdec",
",",
"\"v_encdec\"",
":",
"v_encdec",
"}",
"return",
"cache"
] |
Add attend-to-encoder layers to cache.
|
[
"Add",
"attend",
"-",
"to",
"-",
"encoder",
"layers",
"to",
"cache",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L592-L617
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
_init_evolved_transformer_cache
|
def _init_evolved_transformer_cache(cache, hparams, batch_size,
attention_init_length, encoder_output,
encoder_decoder_attention_bias,
scope_prefix):
"""Create the initial cache for Evolved Transformer fast decoding."""
key_channels = hparams.attention_key_channels or hparams.hidden_size
value_channels = hparams.attention_value_channels or hparams.hidden_size
num_layers = hparams.num_decoder_layers or hparams.num_hidden_layers
vars_3d_num_heads = (
hparams.num_heads if hparams.get("attention_variables_3d") else 0)
# Add self-attentions.
if cache is None:
cache = {}
cache.update({
"layer_%d" % layer: { # pylint: disable=g-complex-comprehension
_SIXTEEN_HEAD_ATTENTION_NAME: {
"k":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, key_channels]),
_capped_double_heads(hparams.num_heads)),
"v":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, value_channels]),
_capped_double_heads(hparams.num_heads)),
},
_VANILLA_ATTENTION_NAME: {
"k":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, key_channels]),
hparams.num_heads),
"v":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, value_channels]),
hparams.num_heads),
}
} for layer in range(num_layers)
})
# Add branched layers. Pad with additional zeros for causal convolution.
for layer in range(num_layers):
cache["layer_%d" % layer][_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.zeros([
batch_size, attention_init_length + _DECODER_LEFT_CONV_PADDING,
hparams.hidden_size
])
cache["layer_%d" % layer][_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.zeros([
batch_size, attention_init_length + _DECODER_FINAL_CONV_PADDING,
hparams.hidden_size * 2
])
# Add encoder embedding attentions.
if encoder_output is not None:
cache = _add_attend_to_encoder_cache(
cache=cache,
attention_name=_FIRST_ATTEND_TO_ENCODER_NAME,
hparams=hparams,
num_layers=num_layers,
key_channels=key_channels,
value_channels=value_channels,
vars_3d_num_heads=vars_3d_num_heads,
scope_prefix=scope_prefix,
encoder_output=encoder_output)
cache = _add_attend_to_encoder_cache(
cache=cache,
attention_name=_SECOND_ATTEND_TO_ENCODER_NAME,
hparams=hparams,
num_layers=num_layers,
key_channels=key_channels,
value_channels=value_channels,
vars_3d_num_heads=vars_3d_num_heads,
scope_prefix=scope_prefix,
encoder_output=encoder_output)
cache["encoder_output"] = encoder_output
cache["encoder_decoder_attention_bias"] = encoder_decoder_attention_bias
return cache
|
python
|
def _init_evolved_transformer_cache(cache, hparams, batch_size,
attention_init_length, encoder_output,
encoder_decoder_attention_bias,
scope_prefix):
"""Create the initial cache for Evolved Transformer fast decoding."""
key_channels = hparams.attention_key_channels or hparams.hidden_size
value_channels = hparams.attention_value_channels or hparams.hidden_size
num_layers = hparams.num_decoder_layers or hparams.num_hidden_layers
vars_3d_num_heads = (
hparams.num_heads if hparams.get("attention_variables_3d") else 0)
# Add self-attentions.
if cache is None:
cache = {}
cache.update({
"layer_%d" % layer: { # pylint: disable=g-complex-comprehension
_SIXTEEN_HEAD_ATTENTION_NAME: {
"k":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, key_channels]),
_capped_double_heads(hparams.num_heads)),
"v":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, value_channels]),
_capped_double_heads(hparams.num_heads)),
},
_VANILLA_ATTENTION_NAME: {
"k":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, key_channels]),
hparams.num_heads),
"v":
common_attention.split_heads(
tf.zeros(
[batch_size, attention_init_length, value_channels]),
hparams.num_heads),
}
} for layer in range(num_layers)
})
# Add branched layers. Pad with additional zeros for causal convolution.
for layer in range(num_layers):
cache["layer_%d" % layer][_CONV_BRANCHES_FIRST_LAYER_NAME] = tf.zeros([
batch_size, attention_init_length + _DECODER_LEFT_CONV_PADDING,
hparams.hidden_size
])
cache["layer_%d" % layer][_CONV_BRANCHES_SECOND_LAYER_NAME] = tf.zeros([
batch_size, attention_init_length + _DECODER_FINAL_CONV_PADDING,
hparams.hidden_size * 2
])
# Add encoder embedding attentions.
if encoder_output is not None:
cache = _add_attend_to_encoder_cache(
cache=cache,
attention_name=_FIRST_ATTEND_TO_ENCODER_NAME,
hparams=hparams,
num_layers=num_layers,
key_channels=key_channels,
value_channels=value_channels,
vars_3d_num_heads=vars_3d_num_heads,
scope_prefix=scope_prefix,
encoder_output=encoder_output)
cache = _add_attend_to_encoder_cache(
cache=cache,
attention_name=_SECOND_ATTEND_TO_ENCODER_NAME,
hparams=hparams,
num_layers=num_layers,
key_channels=key_channels,
value_channels=value_channels,
vars_3d_num_heads=vars_3d_num_heads,
scope_prefix=scope_prefix,
encoder_output=encoder_output)
cache["encoder_output"] = encoder_output
cache["encoder_decoder_attention_bias"] = encoder_decoder_attention_bias
return cache
|
[
"def",
"_init_evolved_transformer_cache",
"(",
"cache",
",",
"hparams",
",",
"batch_size",
",",
"attention_init_length",
",",
"encoder_output",
",",
"encoder_decoder_attention_bias",
",",
"scope_prefix",
")",
":",
"key_channels",
"=",
"hparams",
".",
"attention_key_channels",
"or",
"hparams",
".",
"hidden_size",
"value_channels",
"=",
"hparams",
".",
"attention_value_channels",
"or",
"hparams",
".",
"hidden_size",
"num_layers",
"=",
"hparams",
".",
"num_decoder_layers",
"or",
"hparams",
".",
"num_hidden_layers",
"vars_3d_num_heads",
"=",
"(",
"hparams",
".",
"num_heads",
"if",
"hparams",
".",
"get",
"(",
"\"attention_variables_3d\"",
")",
"else",
"0",
")",
"# Add self-attentions.",
"if",
"cache",
"is",
"None",
":",
"cache",
"=",
"{",
"}",
"cache",
".",
"update",
"(",
"{",
"\"layer_%d\"",
"%",
"layer",
":",
"{",
"# pylint: disable=g-complex-comprehension",
"_SIXTEEN_HEAD_ATTENTION_NAME",
":",
"{",
"\"k\"",
":",
"common_attention",
".",
"split_heads",
"(",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
",",
"key_channels",
"]",
")",
",",
"_capped_double_heads",
"(",
"hparams",
".",
"num_heads",
")",
")",
",",
"\"v\"",
":",
"common_attention",
".",
"split_heads",
"(",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
",",
"value_channels",
"]",
")",
",",
"_capped_double_heads",
"(",
"hparams",
".",
"num_heads",
")",
")",
",",
"}",
",",
"_VANILLA_ATTENTION_NAME",
":",
"{",
"\"k\"",
":",
"common_attention",
".",
"split_heads",
"(",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
",",
"key_channels",
"]",
")",
",",
"hparams",
".",
"num_heads",
")",
",",
"\"v\"",
":",
"common_attention",
".",
"split_heads",
"(",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
",",
"value_channels",
"]",
")",
",",
"hparams",
".",
"num_heads",
")",
",",
"}",
"}",
"for",
"layer",
"in",
"range",
"(",
"num_layers",
")",
"}",
")",
"# Add branched layers. Pad with additional zeros for causal convolution.",
"for",
"layer",
"in",
"range",
"(",
"num_layers",
")",
":",
"cache",
"[",
"\"layer_%d\"",
"%",
"layer",
"]",
"[",
"_CONV_BRANCHES_FIRST_LAYER_NAME",
"]",
"=",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
"+",
"_DECODER_LEFT_CONV_PADDING",
",",
"hparams",
".",
"hidden_size",
"]",
")",
"cache",
"[",
"\"layer_%d\"",
"%",
"layer",
"]",
"[",
"_CONV_BRANCHES_SECOND_LAYER_NAME",
"]",
"=",
"tf",
".",
"zeros",
"(",
"[",
"batch_size",
",",
"attention_init_length",
"+",
"_DECODER_FINAL_CONV_PADDING",
",",
"hparams",
".",
"hidden_size",
"*",
"2",
"]",
")",
"# Add encoder embedding attentions.",
"if",
"encoder_output",
"is",
"not",
"None",
":",
"cache",
"=",
"_add_attend_to_encoder_cache",
"(",
"cache",
"=",
"cache",
",",
"attention_name",
"=",
"_FIRST_ATTEND_TO_ENCODER_NAME",
",",
"hparams",
"=",
"hparams",
",",
"num_layers",
"=",
"num_layers",
",",
"key_channels",
"=",
"key_channels",
",",
"value_channels",
"=",
"value_channels",
",",
"vars_3d_num_heads",
"=",
"vars_3d_num_heads",
",",
"scope_prefix",
"=",
"scope_prefix",
",",
"encoder_output",
"=",
"encoder_output",
")",
"cache",
"=",
"_add_attend_to_encoder_cache",
"(",
"cache",
"=",
"cache",
",",
"attention_name",
"=",
"_SECOND_ATTEND_TO_ENCODER_NAME",
",",
"hparams",
"=",
"hparams",
",",
"num_layers",
"=",
"num_layers",
",",
"key_channels",
"=",
"key_channels",
",",
"value_channels",
"=",
"value_channels",
",",
"vars_3d_num_heads",
"=",
"vars_3d_num_heads",
",",
"scope_prefix",
"=",
"scope_prefix",
",",
"encoder_output",
"=",
"encoder_output",
")",
"cache",
"[",
"\"encoder_output\"",
"]",
"=",
"encoder_output",
"cache",
"[",
"\"encoder_decoder_attention_bias\"",
"]",
"=",
"encoder_decoder_attention_bias",
"return",
"cache"
] |
Create the initial cache for Evolved Transformer fast decoding.
|
[
"Create",
"the",
"initial",
"cache",
"for",
"Evolved",
"Transformer",
"fast",
"decoding",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L620-L700
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
add_evolved_transformer_hparams
|
def add_evolved_transformer_hparams(hparams):
"""Add Evolved Transformer hparams.
Note: These are for the Adam optimizer, not the Adafactor optimizer used in
the paper.
Args:
hparams: Current hparams.
Returns:
hparams updated with Evolved Transformer values.
"""
# Evolved Transformer "layers" are twice as deep as Transformer, so roughly
# halve the number that we use. These numbers are taken from
# arxiv.org/abs/1901.11117 .
hparams.num_encoder_layers = 3
hparams.num_decoder_layers = 4
# Learning rate and decay scheme that mimics the transformer Adam config,
# but with cosine decay instead of rsqrt.
hparams.learning_rate_constant /= hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*linear_warmup*single_cycle_cos_decay*rsqrt_hidden_size")
# The current infrastructure does not support exposing
# `train_steps` to the decay functions, and so we are hard coding the decay
# steps here to match the default number of train steps used in `t2t_trainer`.
# TODO(davidso): Thread `train_steps` through to decay functions so we do not
# have to worry about a `learning_rate_decay_steps` mismatch.
hparams.learning_rate_decay_steps = 250000
return hparams
|
python
|
def add_evolved_transformer_hparams(hparams):
"""Add Evolved Transformer hparams.
Note: These are for the Adam optimizer, not the Adafactor optimizer used in
the paper.
Args:
hparams: Current hparams.
Returns:
hparams updated with Evolved Transformer values.
"""
# Evolved Transformer "layers" are twice as deep as Transformer, so roughly
# halve the number that we use. These numbers are taken from
# arxiv.org/abs/1901.11117 .
hparams.num_encoder_layers = 3
hparams.num_decoder_layers = 4
# Learning rate and decay scheme that mimics the transformer Adam config,
# but with cosine decay instead of rsqrt.
hparams.learning_rate_constant /= hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*linear_warmup*single_cycle_cos_decay*rsqrt_hidden_size")
# The current infrastructure does not support exposing
# `train_steps` to the decay functions, and so we are hard coding the decay
# steps here to match the default number of train steps used in `t2t_trainer`.
# TODO(davidso): Thread `train_steps` through to decay functions so we do not
# have to worry about a `learning_rate_decay_steps` mismatch.
hparams.learning_rate_decay_steps = 250000
return hparams
|
[
"def",
"add_evolved_transformer_hparams",
"(",
"hparams",
")",
":",
"# Evolved Transformer \"layers\" are twice as deep as Transformer, so roughly",
"# halve the number that we use. These numbers are taken from",
"# arxiv.org/abs/1901.11117 .",
"hparams",
".",
"num_encoder_layers",
"=",
"3",
"hparams",
".",
"num_decoder_layers",
"=",
"4",
"# Learning rate and decay scheme that mimics the transformer Adam config,",
"# but with cosine decay instead of rsqrt.",
"hparams",
".",
"learning_rate_constant",
"/=",
"hparams",
".",
"learning_rate_warmup_steps",
"**",
"0.5",
"hparams",
".",
"learning_rate_schedule",
"=",
"(",
"\"constant*linear_warmup*single_cycle_cos_decay*rsqrt_hidden_size\"",
")",
"# The current infrastructure does not support exposing",
"# `train_steps` to the decay functions, and so we are hard coding the decay",
"# steps here to match the default number of train steps used in `t2t_trainer`.",
"# TODO(davidso): Thread `train_steps` through to decay functions so we do not",
"# have to worry about a `learning_rate_decay_steps` mismatch.",
"hparams",
".",
"learning_rate_decay_steps",
"=",
"250000",
"return",
"hparams"
] |
Add Evolved Transformer hparams.
Note: These are for the Adam optimizer, not the Adafactor optimizer used in
the paper.
Args:
hparams: Current hparams.
Returns:
hparams updated with Evolved Transformer values.
|
[
"Add",
"Evolved",
"Transformer",
"hparams",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L704-L733
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
evolved_transformer_base_tpu
|
def evolved_transformer_base_tpu():
"""Base parameters for Evolved Transformer model on TPU."""
hparams = add_evolved_transformer_hparams(transformer.transformer_tpu())
hparams.learning_rate_constant = 1 / hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*single_cycle_cos_decay")
return hparams
|
python
|
def evolved_transformer_base_tpu():
"""Base parameters for Evolved Transformer model on TPU."""
hparams = add_evolved_transformer_hparams(transformer.transformer_tpu())
hparams.learning_rate_constant = 1 / hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*single_cycle_cos_decay")
return hparams
|
[
"def",
"evolved_transformer_base_tpu",
"(",
")",
":",
"hparams",
"=",
"add_evolved_transformer_hparams",
"(",
"transformer",
".",
"transformer_tpu",
"(",
")",
")",
"hparams",
".",
"learning_rate_constant",
"=",
"1",
"/",
"hparams",
".",
"learning_rate_warmup_steps",
"**",
"0.5",
"hparams",
".",
"learning_rate_schedule",
"=",
"(",
"\"constant*single_cycle_cos_decay\"",
")",
"return",
"hparams"
] |
Base parameters for Evolved Transformer model on TPU.
|
[
"Base",
"parameters",
"for",
"Evolved",
"Transformer",
"model",
"on",
"TPU",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L749-L755
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/evolved_transformer.py
|
evolved_transformer_big_tpu
|
def evolved_transformer_big_tpu():
"""Big parameters for Evolved Transformer model on TPU."""
hparams = add_evolved_transformer_hparams(transformer.transformer_big_tpu())
hparams.learning_rate_constant = 1 / hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*single_cycle_cos_decay")
return hparams
|
python
|
def evolved_transformer_big_tpu():
"""Big parameters for Evolved Transformer model on TPU."""
hparams = add_evolved_transformer_hparams(transformer.transformer_big_tpu())
hparams.learning_rate_constant = 1 / hparams.learning_rate_warmup_steps ** 0.5
hparams.learning_rate_schedule = (
"constant*single_cycle_cos_decay")
return hparams
|
[
"def",
"evolved_transformer_big_tpu",
"(",
")",
":",
"hparams",
"=",
"add_evolved_transformer_hparams",
"(",
"transformer",
".",
"transformer_big_tpu",
"(",
")",
")",
"hparams",
".",
"learning_rate_constant",
"=",
"1",
"/",
"hparams",
".",
"learning_rate_warmup_steps",
"**",
"0.5",
"hparams",
".",
"learning_rate_schedule",
"=",
"(",
"\"constant*single_cycle_cos_decay\"",
")",
"return",
"hparams"
] |
Big parameters for Evolved Transformer model on TPU.
|
[
"Big",
"parameters",
"for",
"Evolved",
"Transformer",
"model",
"on",
"TPU",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/evolved_transformer.py#L759-L765
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/moe.py
|
transformer_moe_layer_v1
|
def transformer_moe_layer_v1(inputs, output_dim, hparams, train,
master_dtype=tf.bfloat16,
slice_dtype=tf.float32):
"""Local mixture of experts that works well on TPU.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
The number of parameters in the gating network is:
(input_dim.size * hparams.num_experts) +
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-2 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Args:
inputs: a mtf.Tensor with shape [<batch_dims...>, length_dim, input_dim]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [<batch_dims...>, length_dim, output_dim]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
"""
orig_inputs = inputs
input_dim = inputs.shape.dims[-1]
hidden_dim = mtf.Dimension("expert_hidden", hparams.moe_hidden_size)
experts_dim = mtf.Dimension("experts", hparams.moe_num_experts)
group_size_dim = mtf.Dimension("group", hparams.moe_group_size)
batch_dim = mtf.Dimension(
orig_inputs.shape[0].name,
orig_inputs.shape.size // (group_size_dim.size * input_dim.size))
inputs = mtf.reshape(inputs, [batch_dim, group_size_dim, input_dim])
# Each sequence sends expert_capacity positions to each expert.
capacity_factor = (
hparams.moe_capacity_factor_train if train else
hparams.moe_capacity_factor_eval)
expert_capacity = min(
group_size_dim.size,
int((group_size_dim.size * capacity_factor) / experts_dim.size))
expert_capacity_dim = mtf.Dimension("expert_capacity", expert_capacity)
experts_dim_unsplit = mtf.Dimension("expert_unsplit", experts_dim.size)
batch_dim_unsplit = mtf.Dimension("batch_unsplit", batch_dim.size)
if hparams.moe_gating == "top_2":
dispatch_tensor, combine_tensor, loss = _top_2_gating(
inputs=inputs,
outer_expert_dims=None,
experts_dim=experts_dim_unsplit,
expert_capacity_dim=expert_capacity_dim,
hparams=hparams,
train=train)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# put num_experts dimension first to make split easier in alltoall
expert_inputs = mtf.einsum([inputs, dispatch_tensor], mtf.Shape(
[experts_dim_unsplit, batch_dim, expert_capacity_dim, input_dim]))
expert_inputs = mtf.reshape(expert_inputs, mtf.Shape(
[experts_dim, batch_dim_unsplit, expert_capacity_dim, input_dim]))
# Now feed the expert inputs through the experts.
h = mtf.layers.dense(
expert_inputs, hidden_dim, expert_dims=[experts_dim],
activation=mtf.relu, use_bias=False, master_dtype=master_dtype,
slice_dtype=slice_dtype, name="x0")
expert_output = mtf.layers.dense(
h, output_dim, expert_dims=[experts_dim], use_bias=False,
master_dtype=master_dtype, slice_dtype=slice_dtype, name="x1")
expert_output = mtf.reshape(expert_output, mtf.Shape(
[experts_dim_unsplit, batch_dim, expert_capacity_dim, input_dim]))
output = mtf.einsum([expert_output, combine_tensor], mtf.Shape(
[batch_dim, group_size_dim, output_dim]))
output = mtf.reshape(output, orig_inputs.shape.dims[:-1] + [output_dim])
return output, loss * hparams.moe_loss_coef
|
python
|
def transformer_moe_layer_v1(inputs, output_dim, hparams, train,
master_dtype=tf.bfloat16,
slice_dtype=tf.float32):
"""Local mixture of experts that works well on TPU.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
The number of parameters in the gating network is:
(input_dim.size * hparams.num_experts) +
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-2 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Args:
inputs: a mtf.Tensor with shape [<batch_dims...>, length_dim, input_dim]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [<batch_dims...>, length_dim, output_dim]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
"""
orig_inputs = inputs
input_dim = inputs.shape.dims[-1]
hidden_dim = mtf.Dimension("expert_hidden", hparams.moe_hidden_size)
experts_dim = mtf.Dimension("experts", hparams.moe_num_experts)
group_size_dim = mtf.Dimension("group", hparams.moe_group_size)
batch_dim = mtf.Dimension(
orig_inputs.shape[0].name,
orig_inputs.shape.size // (group_size_dim.size * input_dim.size))
inputs = mtf.reshape(inputs, [batch_dim, group_size_dim, input_dim])
# Each sequence sends expert_capacity positions to each expert.
capacity_factor = (
hparams.moe_capacity_factor_train if train else
hparams.moe_capacity_factor_eval)
expert_capacity = min(
group_size_dim.size,
int((group_size_dim.size * capacity_factor) / experts_dim.size))
expert_capacity_dim = mtf.Dimension("expert_capacity", expert_capacity)
experts_dim_unsplit = mtf.Dimension("expert_unsplit", experts_dim.size)
batch_dim_unsplit = mtf.Dimension("batch_unsplit", batch_dim.size)
if hparams.moe_gating == "top_2":
dispatch_tensor, combine_tensor, loss = _top_2_gating(
inputs=inputs,
outer_expert_dims=None,
experts_dim=experts_dim_unsplit,
expert_capacity_dim=expert_capacity_dim,
hparams=hparams,
train=train)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# put num_experts dimension first to make split easier in alltoall
expert_inputs = mtf.einsum([inputs, dispatch_tensor], mtf.Shape(
[experts_dim_unsplit, batch_dim, expert_capacity_dim, input_dim]))
expert_inputs = mtf.reshape(expert_inputs, mtf.Shape(
[experts_dim, batch_dim_unsplit, expert_capacity_dim, input_dim]))
# Now feed the expert inputs through the experts.
h = mtf.layers.dense(
expert_inputs, hidden_dim, expert_dims=[experts_dim],
activation=mtf.relu, use_bias=False, master_dtype=master_dtype,
slice_dtype=slice_dtype, name="x0")
expert_output = mtf.layers.dense(
h, output_dim, expert_dims=[experts_dim], use_bias=False,
master_dtype=master_dtype, slice_dtype=slice_dtype, name="x1")
expert_output = mtf.reshape(expert_output, mtf.Shape(
[experts_dim_unsplit, batch_dim, expert_capacity_dim, input_dim]))
output = mtf.einsum([expert_output, combine_tensor], mtf.Shape(
[batch_dim, group_size_dim, output_dim]))
output = mtf.reshape(output, orig_inputs.shape.dims[:-1] + [output_dim])
return output, loss * hparams.moe_loss_coef
|
[
"def",
"transformer_moe_layer_v1",
"(",
"inputs",
",",
"output_dim",
",",
"hparams",
",",
"train",
",",
"master_dtype",
"=",
"tf",
".",
"bfloat16",
",",
"slice_dtype",
"=",
"tf",
".",
"float32",
")",
":",
"orig_inputs",
"=",
"inputs",
"input_dim",
"=",
"inputs",
".",
"shape",
".",
"dims",
"[",
"-",
"1",
"]",
"hidden_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_hidden\"",
",",
"hparams",
".",
"moe_hidden_size",
")",
"experts_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"\"experts\"",
",",
"hparams",
".",
"moe_num_experts",
")",
"group_size_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"\"group\"",
",",
"hparams",
".",
"moe_group_size",
")",
"batch_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"orig_inputs",
".",
"shape",
"[",
"0",
"]",
".",
"name",
",",
"orig_inputs",
".",
"shape",
".",
"size",
"//",
"(",
"group_size_dim",
".",
"size",
"*",
"input_dim",
".",
"size",
")",
")",
"inputs",
"=",
"mtf",
".",
"reshape",
"(",
"inputs",
",",
"[",
"batch_dim",
",",
"group_size_dim",
",",
"input_dim",
"]",
")",
"# Each sequence sends expert_capacity positions to each expert.",
"capacity_factor",
"=",
"(",
"hparams",
".",
"moe_capacity_factor_train",
"if",
"train",
"else",
"hparams",
".",
"moe_capacity_factor_eval",
")",
"expert_capacity",
"=",
"min",
"(",
"group_size_dim",
".",
"size",
",",
"int",
"(",
"(",
"group_size_dim",
".",
"size",
"*",
"capacity_factor",
")",
"/",
"experts_dim",
".",
"size",
")",
")",
"expert_capacity_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_capacity\"",
",",
"expert_capacity",
")",
"experts_dim_unsplit",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_unsplit\"",
",",
"experts_dim",
".",
"size",
")",
"batch_dim_unsplit",
"=",
"mtf",
".",
"Dimension",
"(",
"\"batch_unsplit\"",
",",
"batch_dim",
".",
"size",
")",
"if",
"hparams",
".",
"moe_gating",
"==",
"\"top_2\"",
":",
"dispatch_tensor",
",",
"combine_tensor",
",",
"loss",
"=",
"_top_2_gating",
"(",
"inputs",
"=",
"inputs",
",",
"outer_expert_dims",
"=",
"None",
",",
"experts_dim",
"=",
"experts_dim_unsplit",
",",
"expert_capacity_dim",
"=",
"expert_capacity_dim",
",",
"hparams",
"=",
"hparams",
",",
"train",
"=",
"train",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"unknown hparams.moe_gating=%s\"",
"%",
"hparams",
".",
"moe_gating",
")",
"# put num_experts dimension first to make split easier in alltoall",
"expert_inputs",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"inputs",
",",
"dispatch_tensor",
"]",
",",
"mtf",
".",
"Shape",
"(",
"[",
"experts_dim_unsplit",
",",
"batch_dim",
",",
"expert_capacity_dim",
",",
"input_dim",
"]",
")",
")",
"expert_inputs",
"=",
"mtf",
".",
"reshape",
"(",
"expert_inputs",
",",
"mtf",
".",
"Shape",
"(",
"[",
"experts_dim",
",",
"batch_dim_unsplit",
",",
"expert_capacity_dim",
",",
"input_dim",
"]",
")",
")",
"# Now feed the expert inputs through the experts.",
"h",
"=",
"mtf",
".",
"layers",
".",
"dense",
"(",
"expert_inputs",
",",
"hidden_dim",
",",
"expert_dims",
"=",
"[",
"experts_dim",
"]",
",",
"activation",
"=",
"mtf",
".",
"relu",
",",
"use_bias",
"=",
"False",
",",
"master_dtype",
"=",
"master_dtype",
",",
"slice_dtype",
"=",
"slice_dtype",
",",
"name",
"=",
"\"x0\"",
")",
"expert_output",
"=",
"mtf",
".",
"layers",
".",
"dense",
"(",
"h",
",",
"output_dim",
",",
"expert_dims",
"=",
"[",
"experts_dim",
"]",
",",
"use_bias",
"=",
"False",
",",
"master_dtype",
"=",
"master_dtype",
",",
"slice_dtype",
"=",
"slice_dtype",
",",
"name",
"=",
"\"x1\"",
")",
"expert_output",
"=",
"mtf",
".",
"reshape",
"(",
"expert_output",
",",
"mtf",
".",
"Shape",
"(",
"[",
"experts_dim_unsplit",
",",
"batch_dim",
",",
"expert_capacity_dim",
",",
"input_dim",
"]",
")",
")",
"output",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"expert_output",
",",
"combine_tensor",
"]",
",",
"mtf",
".",
"Shape",
"(",
"[",
"batch_dim",
",",
"group_size_dim",
",",
"output_dim",
"]",
")",
")",
"output",
"=",
"mtf",
".",
"reshape",
"(",
"output",
",",
"orig_inputs",
".",
"shape",
".",
"dims",
"[",
":",
"-",
"1",
"]",
"+",
"[",
"output_dim",
"]",
")",
"return",
"output",
",",
"loss",
"*",
"hparams",
".",
"moe_loss_coef"
] |
Local mixture of experts that works well on TPU.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
The number of parameters in the gating network is:
(input_dim.size * hparams.num_experts) +
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-2 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Args:
inputs: a mtf.Tensor with shape [<batch_dims...>, length_dim, input_dim]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [<batch_dims...>, length_dim, output_dim]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
|
[
"Local",
"mixture",
"of",
"experts",
"that",
"works",
"well",
"on",
"TPU",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/moe.py#L30-L156
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/moe.py
|
transformer_moe_layer_v2
|
def transformer_moe_layer_v2(inputs, output_dim, hparams, train,
master_dtype=tf.bfloat16, slice_dtype=tf.float32):
"""2-level mixture of experts.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_capacity_factor_second_level: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
One set of params for experts in first level and different of hparams
per expert in the second level.
The number of parameters in the gating network is:
(input_dim.size * (hparams.num_experts) +
(moe_hidden_size * hparams.num_experts) * hparams.num_experts
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-3 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Dimensions cheat sheet:
a, b: batch size
l: original sequence length
m: input depth
n: output depth
g, h: number of groups
s, t: group size
x, y: number of experts
c, d: expert capacity
input: [a0, b1, l, m]
input: [a0, g1, s, m]
dispatch_tensor_x: [a0, g1, s, x, c]
expert_input: [a0, g1, x, c, m]
alltoall: [a0, g, x1, c, m]
alltoall: [a0, g, x1, c, m]
transpose: [x1, a0, g, c, m]
reshape: [x1, h0, s, m]
assignment2: [x1, h0, t, y, d]
expert_input2: [x1, h0, y, d, m]
alltoall: [x1, h, y0, d, m]
...
reverse of that
gating params 0: [m, x]
gating params 1: [x1, m, y]
expert params:
[x1, y0, m, hidden]
[x1, y0, hidden, n]
Args:
inputs: a mtf.Tensor with shape [a, b, l, m]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [a, b, l, n]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
"""
insert_outer_batch_dim = (len(inputs.shape.dims) == 3)
if insert_outer_batch_dim:
inputs = mtf.reshape(
inputs, [mtf.Dimension("outer_batch", 1)] + inputs.shape.dims)
assert len(hparams.moe_num_experts) == 2
a0, b1, l, m = inputs.shape.dims
hidden_dim = mtf.Dimension("expert_hidden", hparams.moe_hidden_size)
x1 = mtf.Dimension("expert_x", hparams.moe_num_experts[0])
y0 = mtf.Dimension("expert_y", hparams.moe_num_experts[1])
x = mtf.Dimension("expert_x_unsplit", hparams.moe_num_experts[0])
y = mtf.Dimension("expert_y_unsplit", hparams.moe_num_experts[1])
n = output_dim
# We "cheat" here and look at the mesh shape and layout. This is to ensure
# that the number of groups (g.size) is a multiple of the mesh dimension
# over which those groups are split.
num_groups, group_size = _split_into_groups(
b1.size * l.size, hparams.moe_group_size,
mtf.tensor_dim_to_mesh_dim_size(hparams.layout, hparams.mesh_shape, b1))
g1 = mtf.Dimension(b1.name, num_groups)
g = mtf.Dimension(b1.name + "_unsplit", g1.size)
s = mtf.Dimension("group_size_x", group_size)
# Each sequence sends (at most?) expert_capacity positions to each expert.
# Static expert_capacity dimension is needed for expert batch sizes
capacity_factor = (
hparams.moe_capacity_factor_train if train else
hparams.moe_capacity_factor_eval)
expert_capacity = min(s.size, int((s.size * capacity_factor) / x.size))
expert_capacity = max(expert_capacity, 4)
c = mtf.Dimension("expert_capacity_x", expert_capacity)
# We "cheat" here and look at the mesh shape and layout. This is to ensure
# that the number of groups (h.size) is a multiple of the mesh dimension
# over which those groups are split.
num_groups, group_size = _split_into_groups(
a0.size * g.size * c.size,
hparams.moe_group_size,
mtf.tensor_dim_to_mesh_dim_size(hparams.layout, hparams.mesh_shape, a0))
t = mtf.Dimension("group_size_y", group_size)
h0 = mtf.Dimension(a0.name, num_groups)
h = mtf.Dimension(a0.name + "_unsplit", h0.size)
expert_capacity = min(
t.size,
int((t.size * hparams.moe_capacity_factor_second_level) / y.size))
expert_capacity = max(expert_capacity, 4)
d = mtf.Dimension("expert_capacity_y", expert_capacity)
# First level of expert routing
# Reshape the inner batch size to a multiple of group_dim g1 and
# group_size_dim s.
inputs = mtf.reshape(inputs, [a0, g1, s, m])
# Get the assignments for the first level.
# dispatch_tensor_x has shape [a0, g1, s, x, c]
if hparams.moe_gating == "top_2":
dispatch_tensor_x, combine_tensor_x, loss_outer = _top_2_gating(
inputs=inputs,
outer_expert_dims=None,
experts_dim=x,
expert_capacity_dim=c,
hparams=hparams,
train=train)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# Now create expert_inputs based on the assignments.
# put num_experts dimension first to make split easier in alltoall
expert_inputs_x = mtf.einsum([inputs, dispatch_tensor_x], [x, a0, g1, c, m])
# we construct an "importance" Tensor for the inputs to the second-level
# gating. The importance of an input is 1.0 if it represents the
# first-choice expert-group and 0.5 if it represents the second-choice expert
# group. This is used by the second-level gating.
importance = mtf.reduce_sum(combine_tensor_x, output_shape=[x, a0, g1, c])
importance = 0.5 * (
mtf.to_float(mtf.greater(importance, 0.5)) +
mtf.to_float(mtf.greater(importance, 0.0)))
# First level, all to all. Here we change the split dimension from g1 to x1.
expert_inputs_x = mtf.reshape(expert_inputs_x, mtf.Shape(
[x1, a0, g, c, m]))
importance = mtf.reshape(importance, [x1, a0, g, c])
# Second level of expert routing
# Reshape the expert_inputs outer batch dim to be a multiple of group_dim h0
# and group_size_dim t.
inputs_y = mtf.reshape(expert_inputs_x, [x1, h0, t, m])
importance = mtf.reshape(importance, [x1, h0, t])
# Get the assignments for the second level.
# dispatch_tensor_y has shape [x1, h0, t, y, d]
if hparams.moe_gating == "top_2":
dispatch_tensor_y, combine_tensor_y, loss_inner = _top_2_gating(
inputs=inputs_y,
outer_expert_dims=[x1],
experts_dim=y,
expert_capacity_dim=d,
hparams=hparams,
train=train,
importance=importance)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# Now create expert_inputs based on the assignments.
# put num_experts dimension first to make split easier in alltoall
expert_inputs_y = mtf.einsum([inputs_y, dispatch_tensor_y], [y, x1, h0, d, m])
# Second level, all to all. Here we change the split dimension from h0 to y0.
expert_inputs_y = mtf.reshape(expert_inputs_y, mtf.Shape(
[y0, x1, h, d, m]))
hidden_output = mtf.layers.dense(
expert_inputs_y, hidden_dim, expert_dims=[y0, x1],
activation=mtf.relu, use_bias=False, master_dtype=master_dtype,
slice_dtype=slice_dtype, name="expert0")
expert_output = mtf.layers.dense(
hidden_output, output_dim, expert_dims=[y0, x1],
use_bias=False, master_dtype=master_dtype, slice_dtype=slice_dtype,
name="expert1")
# NOW COMBINE EXPERT OUTPUTS (reversing everything we have done)
# expert_output has shape [y0, x1, h, d, n]
# alltoall
expert_output = mtf.reshape(expert_output, mtf.Shape(
[y, x1, h0, d, n]))
# combine results from inner level
output_y = mtf.einsum([expert_output, combine_tensor_y], [x1, h0, t, n])
# Reshape the combined tensor from inner level to now contain outer_batch_dim
# a0 and group_dim g
output = mtf.reshape(output_y, [x1, a0, g, c, n])
# alltoall from expert_dim x to group_dim g1
expert_output_x = mtf.reshape(output, mtf.Shape([x, a0, g1, c, n]))
# combine results from outer level
output_x = mtf.einsum([expert_output_x, combine_tensor_x], [a0, g1, s, n])
# Reshape the combined tensor to now contain inner_batch_dim
# b1 and the original sequence length
output = mtf.reshape(output_x, [a0, b1, l, n])
if insert_outer_batch_dim:
output = mtf.reshape(output, [b1, l, n])
return output, (loss_outer + loss_inner) * hparams.moe_loss_coef
|
python
|
def transformer_moe_layer_v2(inputs, output_dim, hparams, train,
master_dtype=tf.bfloat16, slice_dtype=tf.float32):
"""2-level mixture of experts.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_capacity_factor_second_level: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
One set of params for experts in first level and different of hparams
per expert in the second level.
The number of parameters in the gating network is:
(input_dim.size * (hparams.num_experts) +
(moe_hidden_size * hparams.num_experts) * hparams.num_experts
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-3 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Dimensions cheat sheet:
a, b: batch size
l: original sequence length
m: input depth
n: output depth
g, h: number of groups
s, t: group size
x, y: number of experts
c, d: expert capacity
input: [a0, b1, l, m]
input: [a0, g1, s, m]
dispatch_tensor_x: [a0, g1, s, x, c]
expert_input: [a0, g1, x, c, m]
alltoall: [a0, g, x1, c, m]
alltoall: [a0, g, x1, c, m]
transpose: [x1, a0, g, c, m]
reshape: [x1, h0, s, m]
assignment2: [x1, h0, t, y, d]
expert_input2: [x1, h0, y, d, m]
alltoall: [x1, h, y0, d, m]
...
reverse of that
gating params 0: [m, x]
gating params 1: [x1, m, y]
expert params:
[x1, y0, m, hidden]
[x1, y0, hidden, n]
Args:
inputs: a mtf.Tensor with shape [a, b, l, m]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [a, b, l, n]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
"""
insert_outer_batch_dim = (len(inputs.shape.dims) == 3)
if insert_outer_batch_dim:
inputs = mtf.reshape(
inputs, [mtf.Dimension("outer_batch", 1)] + inputs.shape.dims)
assert len(hparams.moe_num_experts) == 2
a0, b1, l, m = inputs.shape.dims
hidden_dim = mtf.Dimension("expert_hidden", hparams.moe_hidden_size)
x1 = mtf.Dimension("expert_x", hparams.moe_num_experts[0])
y0 = mtf.Dimension("expert_y", hparams.moe_num_experts[1])
x = mtf.Dimension("expert_x_unsplit", hparams.moe_num_experts[0])
y = mtf.Dimension("expert_y_unsplit", hparams.moe_num_experts[1])
n = output_dim
# We "cheat" here and look at the mesh shape and layout. This is to ensure
# that the number of groups (g.size) is a multiple of the mesh dimension
# over which those groups are split.
num_groups, group_size = _split_into_groups(
b1.size * l.size, hparams.moe_group_size,
mtf.tensor_dim_to_mesh_dim_size(hparams.layout, hparams.mesh_shape, b1))
g1 = mtf.Dimension(b1.name, num_groups)
g = mtf.Dimension(b1.name + "_unsplit", g1.size)
s = mtf.Dimension("group_size_x", group_size)
# Each sequence sends (at most?) expert_capacity positions to each expert.
# Static expert_capacity dimension is needed for expert batch sizes
capacity_factor = (
hparams.moe_capacity_factor_train if train else
hparams.moe_capacity_factor_eval)
expert_capacity = min(s.size, int((s.size * capacity_factor) / x.size))
expert_capacity = max(expert_capacity, 4)
c = mtf.Dimension("expert_capacity_x", expert_capacity)
# We "cheat" here and look at the mesh shape and layout. This is to ensure
# that the number of groups (h.size) is a multiple of the mesh dimension
# over which those groups are split.
num_groups, group_size = _split_into_groups(
a0.size * g.size * c.size,
hparams.moe_group_size,
mtf.tensor_dim_to_mesh_dim_size(hparams.layout, hparams.mesh_shape, a0))
t = mtf.Dimension("group_size_y", group_size)
h0 = mtf.Dimension(a0.name, num_groups)
h = mtf.Dimension(a0.name + "_unsplit", h0.size)
expert_capacity = min(
t.size,
int((t.size * hparams.moe_capacity_factor_second_level) / y.size))
expert_capacity = max(expert_capacity, 4)
d = mtf.Dimension("expert_capacity_y", expert_capacity)
# First level of expert routing
# Reshape the inner batch size to a multiple of group_dim g1 and
# group_size_dim s.
inputs = mtf.reshape(inputs, [a0, g1, s, m])
# Get the assignments for the first level.
# dispatch_tensor_x has shape [a0, g1, s, x, c]
if hparams.moe_gating == "top_2":
dispatch_tensor_x, combine_tensor_x, loss_outer = _top_2_gating(
inputs=inputs,
outer_expert_dims=None,
experts_dim=x,
expert_capacity_dim=c,
hparams=hparams,
train=train)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# Now create expert_inputs based on the assignments.
# put num_experts dimension first to make split easier in alltoall
expert_inputs_x = mtf.einsum([inputs, dispatch_tensor_x], [x, a0, g1, c, m])
# we construct an "importance" Tensor for the inputs to the second-level
# gating. The importance of an input is 1.0 if it represents the
# first-choice expert-group and 0.5 if it represents the second-choice expert
# group. This is used by the second-level gating.
importance = mtf.reduce_sum(combine_tensor_x, output_shape=[x, a0, g1, c])
importance = 0.5 * (
mtf.to_float(mtf.greater(importance, 0.5)) +
mtf.to_float(mtf.greater(importance, 0.0)))
# First level, all to all. Here we change the split dimension from g1 to x1.
expert_inputs_x = mtf.reshape(expert_inputs_x, mtf.Shape(
[x1, a0, g, c, m]))
importance = mtf.reshape(importance, [x1, a0, g, c])
# Second level of expert routing
# Reshape the expert_inputs outer batch dim to be a multiple of group_dim h0
# and group_size_dim t.
inputs_y = mtf.reshape(expert_inputs_x, [x1, h0, t, m])
importance = mtf.reshape(importance, [x1, h0, t])
# Get the assignments for the second level.
# dispatch_tensor_y has shape [x1, h0, t, y, d]
if hparams.moe_gating == "top_2":
dispatch_tensor_y, combine_tensor_y, loss_inner = _top_2_gating(
inputs=inputs_y,
outer_expert_dims=[x1],
experts_dim=y,
expert_capacity_dim=d,
hparams=hparams,
train=train,
importance=importance)
else:
raise ValueError("unknown hparams.moe_gating=%s" % hparams.moe_gating)
# Now create expert_inputs based on the assignments.
# put num_experts dimension first to make split easier in alltoall
expert_inputs_y = mtf.einsum([inputs_y, dispatch_tensor_y], [y, x1, h0, d, m])
# Second level, all to all. Here we change the split dimension from h0 to y0.
expert_inputs_y = mtf.reshape(expert_inputs_y, mtf.Shape(
[y0, x1, h, d, m]))
hidden_output = mtf.layers.dense(
expert_inputs_y, hidden_dim, expert_dims=[y0, x1],
activation=mtf.relu, use_bias=False, master_dtype=master_dtype,
slice_dtype=slice_dtype, name="expert0")
expert_output = mtf.layers.dense(
hidden_output, output_dim, expert_dims=[y0, x1],
use_bias=False, master_dtype=master_dtype, slice_dtype=slice_dtype,
name="expert1")
# NOW COMBINE EXPERT OUTPUTS (reversing everything we have done)
# expert_output has shape [y0, x1, h, d, n]
# alltoall
expert_output = mtf.reshape(expert_output, mtf.Shape(
[y, x1, h0, d, n]))
# combine results from inner level
output_y = mtf.einsum([expert_output, combine_tensor_y], [x1, h0, t, n])
# Reshape the combined tensor from inner level to now contain outer_batch_dim
# a0 and group_dim g
output = mtf.reshape(output_y, [x1, a0, g, c, n])
# alltoall from expert_dim x to group_dim g1
expert_output_x = mtf.reshape(output, mtf.Shape([x, a0, g1, c, n]))
# combine results from outer level
output_x = mtf.einsum([expert_output_x, combine_tensor_x], [a0, g1, s, n])
# Reshape the combined tensor to now contain inner_batch_dim
# b1 and the original sequence length
output = mtf.reshape(output_x, [a0, b1, l, n])
if insert_outer_batch_dim:
output = mtf.reshape(output, [b1, l, n])
return output, (loss_outer + loss_inner) * hparams.moe_loss_coef
|
[
"def",
"transformer_moe_layer_v2",
"(",
"inputs",
",",
"output_dim",
",",
"hparams",
",",
"train",
",",
"master_dtype",
"=",
"tf",
".",
"bfloat16",
",",
"slice_dtype",
"=",
"tf",
".",
"float32",
")",
":",
"insert_outer_batch_dim",
"=",
"(",
"len",
"(",
"inputs",
".",
"shape",
".",
"dims",
")",
"==",
"3",
")",
"if",
"insert_outer_batch_dim",
":",
"inputs",
"=",
"mtf",
".",
"reshape",
"(",
"inputs",
",",
"[",
"mtf",
".",
"Dimension",
"(",
"\"outer_batch\"",
",",
"1",
")",
"]",
"+",
"inputs",
".",
"shape",
".",
"dims",
")",
"assert",
"len",
"(",
"hparams",
".",
"moe_num_experts",
")",
"==",
"2",
"a0",
",",
"b1",
",",
"l",
",",
"m",
"=",
"inputs",
".",
"shape",
".",
"dims",
"hidden_dim",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_hidden\"",
",",
"hparams",
".",
"moe_hidden_size",
")",
"x1",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_x\"",
",",
"hparams",
".",
"moe_num_experts",
"[",
"0",
"]",
")",
"y0",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_y\"",
",",
"hparams",
".",
"moe_num_experts",
"[",
"1",
"]",
")",
"x",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_x_unsplit\"",
",",
"hparams",
".",
"moe_num_experts",
"[",
"0",
"]",
")",
"y",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_y_unsplit\"",
",",
"hparams",
".",
"moe_num_experts",
"[",
"1",
"]",
")",
"n",
"=",
"output_dim",
"# We \"cheat\" here and look at the mesh shape and layout. This is to ensure",
"# that the number of groups (g.size) is a multiple of the mesh dimension",
"# over which those groups are split.",
"num_groups",
",",
"group_size",
"=",
"_split_into_groups",
"(",
"b1",
".",
"size",
"*",
"l",
".",
"size",
",",
"hparams",
".",
"moe_group_size",
",",
"mtf",
".",
"tensor_dim_to_mesh_dim_size",
"(",
"hparams",
".",
"layout",
",",
"hparams",
".",
"mesh_shape",
",",
"b1",
")",
")",
"g1",
"=",
"mtf",
".",
"Dimension",
"(",
"b1",
".",
"name",
",",
"num_groups",
")",
"g",
"=",
"mtf",
".",
"Dimension",
"(",
"b1",
".",
"name",
"+",
"\"_unsplit\"",
",",
"g1",
".",
"size",
")",
"s",
"=",
"mtf",
".",
"Dimension",
"(",
"\"group_size_x\"",
",",
"group_size",
")",
"# Each sequence sends (at most?) expert_capacity positions to each expert.",
"# Static expert_capacity dimension is needed for expert batch sizes",
"capacity_factor",
"=",
"(",
"hparams",
".",
"moe_capacity_factor_train",
"if",
"train",
"else",
"hparams",
".",
"moe_capacity_factor_eval",
")",
"expert_capacity",
"=",
"min",
"(",
"s",
".",
"size",
",",
"int",
"(",
"(",
"s",
".",
"size",
"*",
"capacity_factor",
")",
"/",
"x",
".",
"size",
")",
")",
"expert_capacity",
"=",
"max",
"(",
"expert_capacity",
",",
"4",
")",
"c",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_capacity_x\"",
",",
"expert_capacity",
")",
"# We \"cheat\" here and look at the mesh shape and layout. This is to ensure",
"# that the number of groups (h.size) is a multiple of the mesh dimension",
"# over which those groups are split.",
"num_groups",
",",
"group_size",
"=",
"_split_into_groups",
"(",
"a0",
".",
"size",
"*",
"g",
".",
"size",
"*",
"c",
".",
"size",
",",
"hparams",
".",
"moe_group_size",
",",
"mtf",
".",
"tensor_dim_to_mesh_dim_size",
"(",
"hparams",
".",
"layout",
",",
"hparams",
".",
"mesh_shape",
",",
"a0",
")",
")",
"t",
"=",
"mtf",
".",
"Dimension",
"(",
"\"group_size_y\"",
",",
"group_size",
")",
"h0",
"=",
"mtf",
".",
"Dimension",
"(",
"a0",
".",
"name",
",",
"num_groups",
")",
"h",
"=",
"mtf",
".",
"Dimension",
"(",
"a0",
".",
"name",
"+",
"\"_unsplit\"",
",",
"h0",
".",
"size",
")",
"expert_capacity",
"=",
"min",
"(",
"t",
".",
"size",
",",
"int",
"(",
"(",
"t",
".",
"size",
"*",
"hparams",
".",
"moe_capacity_factor_second_level",
")",
"/",
"y",
".",
"size",
")",
")",
"expert_capacity",
"=",
"max",
"(",
"expert_capacity",
",",
"4",
")",
"d",
"=",
"mtf",
".",
"Dimension",
"(",
"\"expert_capacity_y\"",
",",
"expert_capacity",
")",
"# First level of expert routing",
"# Reshape the inner batch size to a multiple of group_dim g1 and",
"# group_size_dim s.",
"inputs",
"=",
"mtf",
".",
"reshape",
"(",
"inputs",
",",
"[",
"a0",
",",
"g1",
",",
"s",
",",
"m",
"]",
")",
"# Get the assignments for the first level.",
"# dispatch_tensor_x has shape [a0, g1, s, x, c]",
"if",
"hparams",
".",
"moe_gating",
"==",
"\"top_2\"",
":",
"dispatch_tensor_x",
",",
"combine_tensor_x",
",",
"loss_outer",
"=",
"_top_2_gating",
"(",
"inputs",
"=",
"inputs",
",",
"outer_expert_dims",
"=",
"None",
",",
"experts_dim",
"=",
"x",
",",
"expert_capacity_dim",
"=",
"c",
",",
"hparams",
"=",
"hparams",
",",
"train",
"=",
"train",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"unknown hparams.moe_gating=%s\"",
"%",
"hparams",
".",
"moe_gating",
")",
"# Now create expert_inputs based on the assignments.",
"# put num_experts dimension first to make split easier in alltoall",
"expert_inputs_x",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"inputs",
",",
"dispatch_tensor_x",
"]",
",",
"[",
"x",
",",
"a0",
",",
"g1",
",",
"c",
",",
"m",
"]",
")",
"# we construct an \"importance\" Tensor for the inputs to the second-level",
"# gating. The importance of an input is 1.0 if it represents the",
"# first-choice expert-group and 0.5 if it represents the second-choice expert",
"# group. This is used by the second-level gating.",
"importance",
"=",
"mtf",
".",
"reduce_sum",
"(",
"combine_tensor_x",
",",
"output_shape",
"=",
"[",
"x",
",",
"a0",
",",
"g1",
",",
"c",
"]",
")",
"importance",
"=",
"0.5",
"*",
"(",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"greater",
"(",
"importance",
",",
"0.5",
")",
")",
"+",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"greater",
"(",
"importance",
",",
"0.0",
")",
")",
")",
"# First level, all to all. Here we change the split dimension from g1 to x1.",
"expert_inputs_x",
"=",
"mtf",
".",
"reshape",
"(",
"expert_inputs_x",
",",
"mtf",
".",
"Shape",
"(",
"[",
"x1",
",",
"a0",
",",
"g",
",",
"c",
",",
"m",
"]",
")",
")",
"importance",
"=",
"mtf",
".",
"reshape",
"(",
"importance",
",",
"[",
"x1",
",",
"a0",
",",
"g",
",",
"c",
"]",
")",
"# Second level of expert routing",
"# Reshape the expert_inputs outer batch dim to be a multiple of group_dim h0",
"# and group_size_dim t.",
"inputs_y",
"=",
"mtf",
".",
"reshape",
"(",
"expert_inputs_x",
",",
"[",
"x1",
",",
"h0",
",",
"t",
",",
"m",
"]",
")",
"importance",
"=",
"mtf",
".",
"reshape",
"(",
"importance",
",",
"[",
"x1",
",",
"h0",
",",
"t",
"]",
")",
"# Get the assignments for the second level.",
"# dispatch_tensor_y has shape [x1, h0, t, y, d]",
"if",
"hparams",
".",
"moe_gating",
"==",
"\"top_2\"",
":",
"dispatch_tensor_y",
",",
"combine_tensor_y",
",",
"loss_inner",
"=",
"_top_2_gating",
"(",
"inputs",
"=",
"inputs_y",
",",
"outer_expert_dims",
"=",
"[",
"x1",
"]",
",",
"experts_dim",
"=",
"y",
",",
"expert_capacity_dim",
"=",
"d",
",",
"hparams",
"=",
"hparams",
",",
"train",
"=",
"train",
",",
"importance",
"=",
"importance",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"unknown hparams.moe_gating=%s\"",
"%",
"hparams",
".",
"moe_gating",
")",
"# Now create expert_inputs based on the assignments.",
"# put num_experts dimension first to make split easier in alltoall",
"expert_inputs_y",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"inputs_y",
",",
"dispatch_tensor_y",
"]",
",",
"[",
"y",
",",
"x1",
",",
"h0",
",",
"d",
",",
"m",
"]",
")",
"# Second level, all to all. Here we change the split dimension from h0 to y0.",
"expert_inputs_y",
"=",
"mtf",
".",
"reshape",
"(",
"expert_inputs_y",
",",
"mtf",
".",
"Shape",
"(",
"[",
"y0",
",",
"x1",
",",
"h",
",",
"d",
",",
"m",
"]",
")",
")",
"hidden_output",
"=",
"mtf",
".",
"layers",
".",
"dense",
"(",
"expert_inputs_y",
",",
"hidden_dim",
",",
"expert_dims",
"=",
"[",
"y0",
",",
"x1",
"]",
",",
"activation",
"=",
"mtf",
".",
"relu",
",",
"use_bias",
"=",
"False",
",",
"master_dtype",
"=",
"master_dtype",
",",
"slice_dtype",
"=",
"slice_dtype",
",",
"name",
"=",
"\"expert0\"",
")",
"expert_output",
"=",
"mtf",
".",
"layers",
".",
"dense",
"(",
"hidden_output",
",",
"output_dim",
",",
"expert_dims",
"=",
"[",
"y0",
",",
"x1",
"]",
",",
"use_bias",
"=",
"False",
",",
"master_dtype",
"=",
"master_dtype",
",",
"slice_dtype",
"=",
"slice_dtype",
",",
"name",
"=",
"\"expert1\"",
")",
"# NOW COMBINE EXPERT OUTPUTS (reversing everything we have done)",
"# expert_output has shape [y0, x1, h, d, n]",
"# alltoall",
"expert_output",
"=",
"mtf",
".",
"reshape",
"(",
"expert_output",
",",
"mtf",
".",
"Shape",
"(",
"[",
"y",
",",
"x1",
",",
"h0",
",",
"d",
",",
"n",
"]",
")",
")",
"# combine results from inner level",
"output_y",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"expert_output",
",",
"combine_tensor_y",
"]",
",",
"[",
"x1",
",",
"h0",
",",
"t",
",",
"n",
"]",
")",
"# Reshape the combined tensor from inner level to now contain outer_batch_dim",
"# a0 and group_dim g",
"output",
"=",
"mtf",
".",
"reshape",
"(",
"output_y",
",",
"[",
"x1",
",",
"a0",
",",
"g",
",",
"c",
",",
"n",
"]",
")",
"# alltoall from expert_dim x to group_dim g1",
"expert_output_x",
"=",
"mtf",
".",
"reshape",
"(",
"output",
",",
"mtf",
".",
"Shape",
"(",
"[",
"x",
",",
"a0",
",",
"g1",
",",
"c",
",",
"n",
"]",
")",
")",
"# combine results from outer level",
"output_x",
"=",
"mtf",
".",
"einsum",
"(",
"[",
"expert_output_x",
",",
"combine_tensor_x",
"]",
",",
"[",
"a0",
",",
"g1",
",",
"s",
",",
"n",
"]",
")",
"# Reshape the combined tensor to now contain inner_batch_dim",
"# b1 and the original sequence length",
"output",
"=",
"mtf",
".",
"reshape",
"(",
"output_x",
",",
"[",
"a0",
",",
"b1",
",",
"l",
",",
"n",
"]",
")",
"if",
"insert_outer_batch_dim",
":",
"output",
"=",
"mtf",
".",
"reshape",
"(",
"output",
",",
"[",
"b1",
",",
"l",
",",
"n",
"]",
")",
"return",
"output",
",",
"(",
"loss_outer",
"+",
"loss_inner",
")",
"*",
"hparams",
".",
"moe_loss_coef"
] |
2-level mixture of experts.
Adapted from the paper https://arxiv.org/abs/1701.06538
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_num_experts: number of experts
hparams.moe_hidden_size: size of hidden layer in each expert
hparams.moe_group_size: size of each "group" for gating purposes
hparams.moe_capacity_factor_train: a float
hparams.moe_capacity_factor_eval: a float
hparams.moe_capacity_factor_second_level: a float
hparams.moe_gating: a string
+ all hyperparmeters used by _top_2_gating()
One set of params for experts in first level and different of hparams
per expert in the second level.
The number of parameters in the gating network is:
(input_dim.size * (hparams.num_experts) +
(moe_hidden_size * hparams.num_experts) * hparams.num_experts
The number of parameters in the experts themselves is:
(hparams.num_experts
* (input_dim.size + output_dim.size)
* hparams.moe_hidden_size)
The input is n-dimensional: [<batch_and_length_dims>, input_dim], consisting
of the representations of all positions in a batch of sequences.
Each position of each sequence is sent to 0-3 experts. The expert
choices and the combination weights are determined by a learned gating
function.
This function returns a small auxiliary loss that should be added to the
training loss of the model. This loss helps to balance expert usage.
Without the loss, it is very likely that a few experts will be trained and
the rest will starve.
Several hacks are necessary to get around current TPU limitations:
- To ensure static shapes, we enforce (by truncation/padding)
that each sequence send the same number of elements to each expert.
It would make more sense to enforce this equality over the entire batch,
but due to our hacked-up gather-by-matmul implementation, we need to divide
the batch into "groups". For each group, the same number of elements
are sent to each expert.
TODO(noam): Factor this code better. We want to be able to substitute
different code for the experts themselves.
Dimensions cheat sheet:
a, b: batch size
l: original sequence length
m: input depth
n: output depth
g, h: number of groups
s, t: group size
x, y: number of experts
c, d: expert capacity
input: [a0, b1, l, m]
input: [a0, g1, s, m]
dispatch_tensor_x: [a0, g1, s, x, c]
expert_input: [a0, g1, x, c, m]
alltoall: [a0, g, x1, c, m]
alltoall: [a0, g, x1, c, m]
transpose: [x1, a0, g, c, m]
reshape: [x1, h0, s, m]
assignment2: [x1, h0, t, y, d]
expert_input2: [x1, h0, y, d, m]
alltoall: [x1, h, y0, d, m]
...
reverse of that
gating params 0: [m, x]
gating params 1: [x1, m, y]
expert params:
[x1, y0, m, hidden]
[x1, y0, hidden, n]
Args:
inputs: a mtf.Tensor with shape [a, b, l, m]
output_dim: a mtf.Dimension (for Transformer, this is input_dim)
hparams: model hyperparameters
train: a boolean
master_dtype: a tf.dtype
slice_dtype: a tf.dtype
Returns:
outputs: a Tensor with shape [a, b, l, n]
loss: a mtf scalar
Raises:
ValueError: on unrecognized hparams.moe_gating
|
[
"2",
"-",
"level",
"mixture",
"of",
"experts",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/moe.py#L159-L411
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/moe.py
|
_top_2_gating
|
def _top_2_gating(
inputs, outer_expert_dims, experts_dim, expert_capacity_dim,
hparams, train, importance=None):
"""Compute gating for mixture-of-experts in TensorFlow.
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_use_second_place_loss: a boolean
hparams.moe_second_policy_train: a string
hparams.moe_second_policy_eval: a string
hparams.moe_second_threshold: a float
The returned forward assignment is a tensor used to map (via einsum) from the
inputs to the expert_inputs. Likewise, the returned combine_tensor is
used to map (via einsum) from the expert outputs to the outputs. Both the
forward and backward assignments are mostly zeros. The shapes of the tensors
are as follows.
inputs: [<batch_dims>, group_size_dim, input_dim]
importance: [<batch_dims>, group_size_dim]
dispatch_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
expert_inputs:
[<batch_dims>, experts_dim, expert_capacity_dim, input_dim]
expert_outputs: [<batch_dims>, experts_dim, expert_capacity_dim, output_dim]
combine_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
outputs: [<batch_dims>, group_size_dim, output_dim]
"importance" is an optional tensor with one floating-point value for each
input vector. If the importance of an input is 1.0, then we send it to
up to 2 experts. If 0.0 < importance < 1.0, then we send it to at most
one expert. If importance == 0.0, then we send it to no experts.
We use "importance" at the second-level gating function of a hierarchical
mixture of experts. Inputs to the first-choice expert-group get importance
1.0. Inputs to the second-choice expert group get importance 0.5.
Inputs that represent padding get importance 0.0.
Args:
inputs: a mtf.Tensor with shape [<batch_dims>, group_size_dim, input_dim]
outer_expert_dims: an optional list of dimensions. This is for the case
where we are at an inner level of a hierarchical MoE.
experts_dim: a Dimension (the number of experts)
expert_capacity_dim: a Dimension (number of examples per group per expert)
hparams: model hyperparameters.
train: a boolean
importance: an optional tensor with shape [<batch_dims>, group_size_dim]
Returns:
dispatch_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
combine_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
loss: a mtf scalar
Raises:
ValueError: on illegal hyperparameters
"""
group_size_dim, unused_input_dim = inputs.shape.dims[-2:]
raw_gates = mtf.softmax(mtf.layers.dense(
inputs, experts_dim, use_bias=False,
expert_dims=outer_expert_dims), experts_dim)
# The internals of this function run in float32.
# bfloat16 seems to reduce quality.
raw_gates = mtf.to_float(raw_gates)
expert_capacity_f = float(expert_capacity_dim.size)
# FIND TOP 2 EXPERTS PER POSITON
# Find the top expert for each position. shape=[batch, group]
index_1, gate_1 = mtf.top_1(raw_gates, experts_dim)
# [batch, group, experts]
mask_1 = mtf.one_hot(index_1, experts_dim, dtype=raw_gates.dtype)
density_1_proxy = raw_gates
if importance is not None:
mask_1 *= mtf.to_float(mtf.equal(importance, 1.0))
gate_1 *= mtf.to_float(mtf.equal(importance, 1.0))
density_1_proxy *= mtf.to_float(mtf.equal(importance, 1.0))
gates_without_top_1 = raw_gates * (1.0 - mask_1)
# [batch, group]
index_2, gate_2 = mtf.top_1(gates_without_top_1, experts_dim)
# [batch, group, experts]
mask_2 = mtf.one_hot(index_2, experts_dim, dtype=raw_gates.dtype)
if importance is not None:
mask_2 *= mtf.to_float(mtf.greater(importance, 0.0))
denom = gate_1 + gate_2 + 1e-9
gate_1 /= denom
gate_2 /= denom
# BALANCING LOSSES
# shape = [batch, experts]
# We want to equalize the fraction of the batch assigned to each expert
density_1 = mtf.reduce_mean(mask_1, reduced_dim=group_size_dim)
# Something continuous that is correlated with what we want to equalize.
density_1_proxy = mtf.reduce_mean(density_1_proxy, reduced_dim=group_size_dim)
density_1 = mtf.Print(
density_1, [mtf.reduce_mean(density_1, output_shape=[experts_dim])],
"density_1", summarize=1000)
loss = (mtf.reduce_mean(density_1_proxy * density_1)
* float(experts_dim.size * experts_dim.size))
if hparams.moe_use_second_place_loss:
# Also add a loss to encourage all experts to be used equally also as the
# second-place expert. Experimentally, this seems to be a wash.
# We want to equalize the fraction of the batch assigned to each expert:
density_2 = mtf.reduce_mean(mask_2, reduced_dim=group_size_dim)
# As a proxy for density_2, we renormalize the raw gates after the top one
# has been removed.
normalized = gates_without_top_1 / (
mtf.reduce_sum(gates_without_top_1, reduced_dim=experts_dim) + 1e-9)
density_2_proxy = mtf.reduce_mean(normalized, reduced_dim=group_size_dim)
loss_2 = (mtf.reduce_mean(density_2_proxy * density_2)
* float(experts_dim.size * experts_dim.size))
loss += loss_2 * 0.5
# Depending on the policy in the hparams, we may drop out some of the
# second-place experts.
policy = (
hparams.moe_second_policy_train if train else
hparams.moe_second_policy_eval)
threshold = (
hparams.moe_second_threshold_train if train else
hparams.moe_second_threshold_eval)
if policy == "all":
# Use second-place experts for all examples.
pass
elif policy == "none":
# Never use second-place experts for all examples.
mask_2 = mtf.zeros_like(mask_2)
elif policy == "threshold":
# Use second-place experts if gate_2 > threshold.
mask_2 *= mtf.to_float(mtf.greater(gate_2, threshold))
elif policy == "random":
# Use second-place experts with probablity min(1.0, gate_2 / threshold).
mask_2 *= mtf.to_float(
mtf.less(mtf.random_uniform(gate_2.mesh, gate_2.shape),
gate_2 / max(threshold, 1e-9)))
else:
raise ValueError("Unknown policy %s" % policy)
mask_2 = mtf.Print(
mask_2, [mtf.reduce_mean(mask_2, output_shape=[experts_dim])],
"density_2", summarize=1000)
# COMPUTE ASSIGNMENT TO EXPERTS
# [batch, group, experts]
# This is the position within the expert's mini-batch for this sequence
position_in_expert_1 = mtf.cumsum(
mask_1, group_size_dim, exclusive=True) * mask_1
# Remove the elements that don't fit. [batch, group, experts]
mask_1 *= mtf.to_float(mtf.less(position_in_expert_1, expert_capacity_f))
# [batch, experts]
# How many examples in this sequence go to this expert
mask_1_count = mtf.reduce_sum(mask_1, reduced_dim=group_size_dim)
# [batch, group] - mostly ones, but zeros where something didn't fit
mask_1_flat = mtf.reduce_sum(mask_1, reduced_dim=experts_dim)
# [batch, group]
position_in_expert_1 = mtf.reduce_sum(
position_in_expert_1, reduced_dim=experts_dim)
# Weight assigned to first expert. [batch, group]
gate_1 *= mask_1_flat
# [batch, group, experts]
position_in_expert_2 = (
mtf.cumsum(mask_2, group_size_dim, exclusive=True) + mask_1_count)
position_in_expert_2 *= mask_2
mask_2 *= mtf.to_float(mtf.less(position_in_expert_2, expert_capacity_f))
# mask_2_count = mtf.reduce_sum(mask_2, reduced_dim=experts_dim)
mask_2_flat = mtf.reduce_sum(mask_2, reduced_dim=experts_dim)
gate_2 *= mask_2_flat
position_in_expert_2 = mtf.reduce_sum(
position_in_expert_2, reduced_dim=experts_dim)
# [batch, group, experts, expert_capacity]
combine_tensor = (
gate_1 * mask_1_flat
* mtf.one_hot(index_1, experts_dim)
* mtf.one_hot(mtf.to_int32(position_in_expert_1), expert_capacity_dim) +
gate_2 * mask_2_flat
* mtf.one_hot(index_2, experts_dim)
* mtf.one_hot(mtf.to_int32(position_in_expert_2), expert_capacity_dim))
combine_tensor = mtf.cast(combine_tensor, inputs.dtype)
loss = mtf.cast(loss, inputs.dtype)
dispatch_tensor = mtf.cast(
mtf.cast(combine_tensor, tf.bool), combine_tensor.dtype)
return dispatch_tensor, combine_tensor, loss
|
python
|
def _top_2_gating(
inputs, outer_expert_dims, experts_dim, expert_capacity_dim,
hparams, train, importance=None):
"""Compute gating for mixture-of-experts in TensorFlow.
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_use_second_place_loss: a boolean
hparams.moe_second_policy_train: a string
hparams.moe_second_policy_eval: a string
hparams.moe_second_threshold: a float
The returned forward assignment is a tensor used to map (via einsum) from the
inputs to the expert_inputs. Likewise, the returned combine_tensor is
used to map (via einsum) from the expert outputs to the outputs. Both the
forward and backward assignments are mostly zeros. The shapes of the tensors
are as follows.
inputs: [<batch_dims>, group_size_dim, input_dim]
importance: [<batch_dims>, group_size_dim]
dispatch_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
expert_inputs:
[<batch_dims>, experts_dim, expert_capacity_dim, input_dim]
expert_outputs: [<batch_dims>, experts_dim, expert_capacity_dim, output_dim]
combine_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
outputs: [<batch_dims>, group_size_dim, output_dim]
"importance" is an optional tensor with one floating-point value for each
input vector. If the importance of an input is 1.0, then we send it to
up to 2 experts. If 0.0 < importance < 1.0, then we send it to at most
one expert. If importance == 0.0, then we send it to no experts.
We use "importance" at the second-level gating function of a hierarchical
mixture of experts. Inputs to the first-choice expert-group get importance
1.0. Inputs to the second-choice expert group get importance 0.5.
Inputs that represent padding get importance 0.0.
Args:
inputs: a mtf.Tensor with shape [<batch_dims>, group_size_dim, input_dim]
outer_expert_dims: an optional list of dimensions. This is for the case
where we are at an inner level of a hierarchical MoE.
experts_dim: a Dimension (the number of experts)
expert_capacity_dim: a Dimension (number of examples per group per expert)
hparams: model hyperparameters.
train: a boolean
importance: an optional tensor with shape [<batch_dims>, group_size_dim]
Returns:
dispatch_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
combine_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
loss: a mtf scalar
Raises:
ValueError: on illegal hyperparameters
"""
group_size_dim, unused_input_dim = inputs.shape.dims[-2:]
raw_gates = mtf.softmax(mtf.layers.dense(
inputs, experts_dim, use_bias=False,
expert_dims=outer_expert_dims), experts_dim)
# The internals of this function run in float32.
# bfloat16 seems to reduce quality.
raw_gates = mtf.to_float(raw_gates)
expert_capacity_f = float(expert_capacity_dim.size)
# FIND TOP 2 EXPERTS PER POSITON
# Find the top expert for each position. shape=[batch, group]
index_1, gate_1 = mtf.top_1(raw_gates, experts_dim)
# [batch, group, experts]
mask_1 = mtf.one_hot(index_1, experts_dim, dtype=raw_gates.dtype)
density_1_proxy = raw_gates
if importance is not None:
mask_1 *= mtf.to_float(mtf.equal(importance, 1.0))
gate_1 *= mtf.to_float(mtf.equal(importance, 1.0))
density_1_proxy *= mtf.to_float(mtf.equal(importance, 1.0))
gates_without_top_1 = raw_gates * (1.0 - mask_1)
# [batch, group]
index_2, gate_2 = mtf.top_1(gates_without_top_1, experts_dim)
# [batch, group, experts]
mask_2 = mtf.one_hot(index_2, experts_dim, dtype=raw_gates.dtype)
if importance is not None:
mask_2 *= mtf.to_float(mtf.greater(importance, 0.0))
denom = gate_1 + gate_2 + 1e-9
gate_1 /= denom
gate_2 /= denom
# BALANCING LOSSES
# shape = [batch, experts]
# We want to equalize the fraction of the batch assigned to each expert
density_1 = mtf.reduce_mean(mask_1, reduced_dim=group_size_dim)
# Something continuous that is correlated with what we want to equalize.
density_1_proxy = mtf.reduce_mean(density_1_proxy, reduced_dim=group_size_dim)
density_1 = mtf.Print(
density_1, [mtf.reduce_mean(density_1, output_shape=[experts_dim])],
"density_1", summarize=1000)
loss = (mtf.reduce_mean(density_1_proxy * density_1)
* float(experts_dim.size * experts_dim.size))
if hparams.moe_use_second_place_loss:
# Also add a loss to encourage all experts to be used equally also as the
# second-place expert. Experimentally, this seems to be a wash.
# We want to equalize the fraction of the batch assigned to each expert:
density_2 = mtf.reduce_mean(mask_2, reduced_dim=group_size_dim)
# As a proxy for density_2, we renormalize the raw gates after the top one
# has been removed.
normalized = gates_without_top_1 / (
mtf.reduce_sum(gates_without_top_1, reduced_dim=experts_dim) + 1e-9)
density_2_proxy = mtf.reduce_mean(normalized, reduced_dim=group_size_dim)
loss_2 = (mtf.reduce_mean(density_2_proxy * density_2)
* float(experts_dim.size * experts_dim.size))
loss += loss_2 * 0.5
# Depending on the policy in the hparams, we may drop out some of the
# second-place experts.
policy = (
hparams.moe_second_policy_train if train else
hparams.moe_second_policy_eval)
threshold = (
hparams.moe_second_threshold_train if train else
hparams.moe_second_threshold_eval)
if policy == "all":
# Use second-place experts for all examples.
pass
elif policy == "none":
# Never use second-place experts for all examples.
mask_2 = mtf.zeros_like(mask_2)
elif policy == "threshold":
# Use second-place experts if gate_2 > threshold.
mask_2 *= mtf.to_float(mtf.greater(gate_2, threshold))
elif policy == "random":
# Use second-place experts with probablity min(1.0, gate_2 / threshold).
mask_2 *= mtf.to_float(
mtf.less(mtf.random_uniform(gate_2.mesh, gate_2.shape),
gate_2 / max(threshold, 1e-9)))
else:
raise ValueError("Unknown policy %s" % policy)
mask_2 = mtf.Print(
mask_2, [mtf.reduce_mean(mask_2, output_shape=[experts_dim])],
"density_2", summarize=1000)
# COMPUTE ASSIGNMENT TO EXPERTS
# [batch, group, experts]
# This is the position within the expert's mini-batch for this sequence
position_in_expert_1 = mtf.cumsum(
mask_1, group_size_dim, exclusive=True) * mask_1
# Remove the elements that don't fit. [batch, group, experts]
mask_1 *= mtf.to_float(mtf.less(position_in_expert_1, expert_capacity_f))
# [batch, experts]
# How many examples in this sequence go to this expert
mask_1_count = mtf.reduce_sum(mask_1, reduced_dim=group_size_dim)
# [batch, group] - mostly ones, but zeros where something didn't fit
mask_1_flat = mtf.reduce_sum(mask_1, reduced_dim=experts_dim)
# [batch, group]
position_in_expert_1 = mtf.reduce_sum(
position_in_expert_1, reduced_dim=experts_dim)
# Weight assigned to first expert. [batch, group]
gate_1 *= mask_1_flat
# [batch, group, experts]
position_in_expert_2 = (
mtf.cumsum(mask_2, group_size_dim, exclusive=True) + mask_1_count)
position_in_expert_2 *= mask_2
mask_2 *= mtf.to_float(mtf.less(position_in_expert_2, expert_capacity_f))
# mask_2_count = mtf.reduce_sum(mask_2, reduced_dim=experts_dim)
mask_2_flat = mtf.reduce_sum(mask_2, reduced_dim=experts_dim)
gate_2 *= mask_2_flat
position_in_expert_2 = mtf.reduce_sum(
position_in_expert_2, reduced_dim=experts_dim)
# [batch, group, experts, expert_capacity]
combine_tensor = (
gate_1 * mask_1_flat
* mtf.one_hot(index_1, experts_dim)
* mtf.one_hot(mtf.to_int32(position_in_expert_1), expert_capacity_dim) +
gate_2 * mask_2_flat
* mtf.one_hot(index_2, experts_dim)
* mtf.one_hot(mtf.to_int32(position_in_expert_2), expert_capacity_dim))
combine_tensor = mtf.cast(combine_tensor, inputs.dtype)
loss = mtf.cast(loss, inputs.dtype)
dispatch_tensor = mtf.cast(
mtf.cast(combine_tensor, tf.bool), combine_tensor.dtype)
return dispatch_tensor, combine_tensor, loss
|
[
"def",
"_top_2_gating",
"(",
"inputs",
",",
"outer_expert_dims",
",",
"experts_dim",
",",
"expert_capacity_dim",
",",
"hparams",
",",
"train",
",",
"importance",
"=",
"None",
")",
":",
"group_size_dim",
",",
"unused_input_dim",
"=",
"inputs",
".",
"shape",
".",
"dims",
"[",
"-",
"2",
":",
"]",
"raw_gates",
"=",
"mtf",
".",
"softmax",
"(",
"mtf",
".",
"layers",
".",
"dense",
"(",
"inputs",
",",
"experts_dim",
",",
"use_bias",
"=",
"False",
",",
"expert_dims",
"=",
"outer_expert_dims",
")",
",",
"experts_dim",
")",
"# The internals of this function run in float32.",
"# bfloat16 seems to reduce quality.",
"raw_gates",
"=",
"mtf",
".",
"to_float",
"(",
"raw_gates",
")",
"expert_capacity_f",
"=",
"float",
"(",
"expert_capacity_dim",
".",
"size",
")",
"# FIND TOP 2 EXPERTS PER POSITON",
"# Find the top expert for each position. shape=[batch, group]",
"index_1",
",",
"gate_1",
"=",
"mtf",
".",
"top_1",
"(",
"raw_gates",
",",
"experts_dim",
")",
"# [batch, group, experts]",
"mask_1",
"=",
"mtf",
".",
"one_hot",
"(",
"index_1",
",",
"experts_dim",
",",
"dtype",
"=",
"raw_gates",
".",
"dtype",
")",
"density_1_proxy",
"=",
"raw_gates",
"if",
"importance",
"is",
"not",
"None",
":",
"mask_1",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"equal",
"(",
"importance",
",",
"1.0",
")",
")",
"gate_1",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"equal",
"(",
"importance",
",",
"1.0",
")",
")",
"density_1_proxy",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"equal",
"(",
"importance",
",",
"1.0",
")",
")",
"gates_without_top_1",
"=",
"raw_gates",
"*",
"(",
"1.0",
"-",
"mask_1",
")",
"# [batch, group]",
"index_2",
",",
"gate_2",
"=",
"mtf",
".",
"top_1",
"(",
"gates_without_top_1",
",",
"experts_dim",
")",
"# [batch, group, experts]",
"mask_2",
"=",
"mtf",
".",
"one_hot",
"(",
"index_2",
",",
"experts_dim",
",",
"dtype",
"=",
"raw_gates",
".",
"dtype",
")",
"if",
"importance",
"is",
"not",
"None",
":",
"mask_2",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"greater",
"(",
"importance",
",",
"0.0",
")",
")",
"denom",
"=",
"gate_1",
"+",
"gate_2",
"+",
"1e-9",
"gate_1",
"/=",
"denom",
"gate_2",
"/=",
"denom",
"# BALANCING LOSSES",
"# shape = [batch, experts]",
"# We want to equalize the fraction of the batch assigned to each expert",
"density_1",
"=",
"mtf",
".",
"reduce_mean",
"(",
"mask_1",
",",
"reduced_dim",
"=",
"group_size_dim",
")",
"# Something continuous that is correlated with what we want to equalize.",
"density_1_proxy",
"=",
"mtf",
".",
"reduce_mean",
"(",
"density_1_proxy",
",",
"reduced_dim",
"=",
"group_size_dim",
")",
"density_1",
"=",
"mtf",
".",
"Print",
"(",
"density_1",
",",
"[",
"mtf",
".",
"reduce_mean",
"(",
"density_1",
",",
"output_shape",
"=",
"[",
"experts_dim",
"]",
")",
"]",
",",
"\"density_1\"",
",",
"summarize",
"=",
"1000",
")",
"loss",
"=",
"(",
"mtf",
".",
"reduce_mean",
"(",
"density_1_proxy",
"*",
"density_1",
")",
"*",
"float",
"(",
"experts_dim",
".",
"size",
"*",
"experts_dim",
".",
"size",
")",
")",
"if",
"hparams",
".",
"moe_use_second_place_loss",
":",
"# Also add a loss to encourage all experts to be used equally also as the",
"# second-place expert. Experimentally, this seems to be a wash.",
"# We want to equalize the fraction of the batch assigned to each expert:",
"density_2",
"=",
"mtf",
".",
"reduce_mean",
"(",
"mask_2",
",",
"reduced_dim",
"=",
"group_size_dim",
")",
"# As a proxy for density_2, we renormalize the raw gates after the top one",
"# has been removed.",
"normalized",
"=",
"gates_without_top_1",
"/",
"(",
"mtf",
".",
"reduce_sum",
"(",
"gates_without_top_1",
",",
"reduced_dim",
"=",
"experts_dim",
")",
"+",
"1e-9",
")",
"density_2_proxy",
"=",
"mtf",
".",
"reduce_mean",
"(",
"normalized",
",",
"reduced_dim",
"=",
"group_size_dim",
")",
"loss_2",
"=",
"(",
"mtf",
".",
"reduce_mean",
"(",
"density_2_proxy",
"*",
"density_2",
")",
"*",
"float",
"(",
"experts_dim",
".",
"size",
"*",
"experts_dim",
".",
"size",
")",
")",
"loss",
"+=",
"loss_2",
"*",
"0.5",
"# Depending on the policy in the hparams, we may drop out some of the",
"# second-place experts.",
"policy",
"=",
"(",
"hparams",
".",
"moe_second_policy_train",
"if",
"train",
"else",
"hparams",
".",
"moe_second_policy_eval",
")",
"threshold",
"=",
"(",
"hparams",
".",
"moe_second_threshold_train",
"if",
"train",
"else",
"hparams",
".",
"moe_second_threshold_eval",
")",
"if",
"policy",
"==",
"\"all\"",
":",
"# Use second-place experts for all examples.",
"pass",
"elif",
"policy",
"==",
"\"none\"",
":",
"# Never use second-place experts for all examples.",
"mask_2",
"=",
"mtf",
".",
"zeros_like",
"(",
"mask_2",
")",
"elif",
"policy",
"==",
"\"threshold\"",
":",
"# Use second-place experts if gate_2 > threshold.",
"mask_2",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"greater",
"(",
"gate_2",
",",
"threshold",
")",
")",
"elif",
"policy",
"==",
"\"random\"",
":",
"# Use second-place experts with probablity min(1.0, gate_2 / threshold).",
"mask_2",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"less",
"(",
"mtf",
".",
"random_uniform",
"(",
"gate_2",
".",
"mesh",
",",
"gate_2",
".",
"shape",
")",
",",
"gate_2",
"/",
"max",
"(",
"threshold",
",",
"1e-9",
")",
")",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown policy %s\"",
"%",
"policy",
")",
"mask_2",
"=",
"mtf",
".",
"Print",
"(",
"mask_2",
",",
"[",
"mtf",
".",
"reduce_mean",
"(",
"mask_2",
",",
"output_shape",
"=",
"[",
"experts_dim",
"]",
")",
"]",
",",
"\"density_2\"",
",",
"summarize",
"=",
"1000",
")",
"# COMPUTE ASSIGNMENT TO EXPERTS",
"# [batch, group, experts]",
"# This is the position within the expert's mini-batch for this sequence",
"position_in_expert_1",
"=",
"mtf",
".",
"cumsum",
"(",
"mask_1",
",",
"group_size_dim",
",",
"exclusive",
"=",
"True",
")",
"*",
"mask_1",
"# Remove the elements that don't fit. [batch, group, experts]",
"mask_1",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"less",
"(",
"position_in_expert_1",
",",
"expert_capacity_f",
")",
")",
"# [batch, experts]",
"# How many examples in this sequence go to this expert",
"mask_1_count",
"=",
"mtf",
".",
"reduce_sum",
"(",
"mask_1",
",",
"reduced_dim",
"=",
"group_size_dim",
")",
"# [batch, group] - mostly ones, but zeros where something didn't fit",
"mask_1_flat",
"=",
"mtf",
".",
"reduce_sum",
"(",
"mask_1",
",",
"reduced_dim",
"=",
"experts_dim",
")",
"# [batch, group]",
"position_in_expert_1",
"=",
"mtf",
".",
"reduce_sum",
"(",
"position_in_expert_1",
",",
"reduced_dim",
"=",
"experts_dim",
")",
"# Weight assigned to first expert. [batch, group]",
"gate_1",
"*=",
"mask_1_flat",
"# [batch, group, experts]",
"position_in_expert_2",
"=",
"(",
"mtf",
".",
"cumsum",
"(",
"mask_2",
",",
"group_size_dim",
",",
"exclusive",
"=",
"True",
")",
"+",
"mask_1_count",
")",
"position_in_expert_2",
"*=",
"mask_2",
"mask_2",
"*=",
"mtf",
".",
"to_float",
"(",
"mtf",
".",
"less",
"(",
"position_in_expert_2",
",",
"expert_capacity_f",
")",
")",
"# mask_2_count = mtf.reduce_sum(mask_2, reduced_dim=experts_dim)",
"mask_2_flat",
"=",
"mtf",
".",
"reduce_sum",
"(",
"mask_2",
",",
"reduced_dim",
"=",
"experts_dim",
")",
"gate_2",
"*=",
"mask_2_flat",
"position_in_expert_2",
"=",
"mtf",
".",
"reduce_sum",
"(",
"position_in_expert_2",
",",
"reduced_dim",
"=",
"experts_dim",
")",
"# [batch, group, experts, expert_capacity]",
"combine_tensor",
"=",
"(",
"gate_1",
"*",
"mask_1_flat",
"*",
"mtf",
".",
"one_hot",
"(",
"index_1",
",",
"experts_dim",
")",
"*",
"mtf",
".",
"one_hot",
"(",
"mtf",
".",
"to_int32",
"(",
"position_in_expert_1",
")",
",",
"expert_capacity_dim",
")",
"+",
"gate_2",
"*",
"mask_2_flat",
"*",
"mtf",
".",
"one_hot",
"(",
"index_2",
",",
"experts_dim",
")",
"*",
"mtf",
".",
"one_hot",
"(",
"mtf",
".",
"to_int32",
"(",
"position_in_expert_2",
")",
",",
"expert_capacity_dim",
")",
")",
"combine_tensor",
"=",
"mtf",
".",
"cast",
"(",
"combine_tensor",
",",
"inputs",
".",
"dtype",
")",
"loss",
"=",
"mtf",
".",
"cast",
"(",
"loss",
",",
"inputs",
".",
"dtype",
")",
"dispatch_tensor",
"=",
"mtf",
".",
"cast",
"(",
"mtf",
".",
"cast",
"(",
"combine_tensor",
",",
"tf",
".",
"bool",
")",
",",
"combine_tensor",
".",
"dtype",
")",
"return",
"dispatch_tensor",
",",
"combine_tensor",
",",
"loss"
] |
Compute gating for mixture-of-experts in TensorFlow.
Note: until the algorithm and inferface solidify, we pass in a hyperparameters
dictionary in order not to complicate the interface in mtf_transformer.py .
Once this code moves out of "research", we should pass the hyperparameters
separately.
Hyperparameters used:
hparams.moe_use_second_place_loss: a boolean
hparams.moe_second_policy_train: a string
hparams.moe_second_policy_eval: a string
hparams.moe_second_threshold: a float
The returned forward assignment is a tensor used to map (via einsum) from the
inputs to the expert_inputs. Likewise, the returned combine_tensor is
used to map (via einsum) from the expert outputs to the outputs. Both the
forward and backward assignments are mostly zeros. The shapes of the tensors
are as follows.
inputs: [<batch_dims>, group_size_dim, input_dim]
importance: [<batch_dims>, group_size_dim]
dispatch_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
expert_inputs:
[<batch_dims>, experts_dim, expert_capacity_dim, input_dim]
expert_outputs: [<batch_dims>, experts_dim, expert_capacity_dim, output_dim]
combine_tensor:
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
outputs: [<batch_dims>, group_size_dim, output_dim]
"importance" is an optional tensor with one floating-point value for each
input vector. If the importance of an input is 1.0, then we send it to
up to 2 experts. If 0.0 < importance < 1.0, then we send it to at most
one expert. If importance == 0.0, then we send it to no experts.
We use "importance" at the second-level gating function of a hierarchical
mixture of experts. Inputs to the first-choice expert-group get importance
1.0. Inputs to the second-choice expert group get importance 0.5.
Inputs that represent padding get importance 0.0.
Args:
inputs: a mtf.Tensor with shape [<batch_dims>, group_size_dim, input_dim]
outer_expert_dims: an optional list of dimensions. This is for the case
where we are at an inner level of a hierarchical MoE.
experts_dim: a Dimension (the number of experts)
expert_capacity_dim: a Dimension (number of examples per group per expert)
hparams: model hyperparameters.
train: a boolean
importance: an optional tensor with shape [<batch_dims>, group_size_dim]
Returns:
dispatch_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
combine_tensor: a Tensor with shape
[<batch_dims>, group_size_dim, experts_dim, expert_capacity_dim]
loss: a mtf scalar
Raises:
ValueError: on illegal hyperparameters
|
[
"Compute",
"gating",
"for",
"mixture",
"-",
"of",
"-",
"experts",
"in",
"TensorFlow",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/moe.py#L414-L610
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/moe.py
|
set_default_moe_hparams
|
def set_default_moe_hparams(hparams):
"""Add necessary hyperparameters for mixture-of-experts."""
hparams.moe_num_experts = 16
hparams.moe_loss_coef = 1e-2
hparams.add_hparam("moe_gating", "top_2")
# Experts have fixed capacity per batch. We need some extra capacity
# in case gating is not perfectly balanced.
# moe_capacity_factor_* should be set to a value >=1.
hparams.add_hparam("moe_capacity_factor_train", 1.25)
hparams.add_hparam("moe_capacity_factor_eval", 2.0)
hparams.add_hparam("moe_capacity_factor_second_level", 1.0)
# Each expert has a hidden layer with this size.
hparams.add_hparam("moe_hidden_size", 4096)
# For gating, divide inputs into groups of this size before gating.
# Each group sends the same number of inputs to each expert.
# Ideally, the group size would be the whole batch, but this is expensive
# due to our use of matrix multiplication for reordering.
hparams.add_hparam("moe_group_size", 1024)
# For top_2 gating, whether to impose an additional loss in order to make
# the experts equally used as the second-place expert.
hparams.add_hparam("moe_use_second_place_loss", 0)
# In top_2 gating, policy for whether to use a second-place expert.
# Legal values are:
# "all": always
# "none": never
# "threshold": if gate value > the given threshold
# "random": if gate value > threshold*random_uniform(0,1)
hparams.add_hparam("moe_second_policy_train", "random")
hparams.add_hparam("moe_second_policy_eval", "random")
hparams.add_hparam("moe_second_threshold_train", 0.2)
hparams.add_hparam("moe_second_threshold_eval", 0.2)
|
python
|
def set_default_moe_hparams(hparams):
"""Add necessary hyperparameters for mixture-of-experts."""
hparams.moe_num_experts = 16
hparams.moe_loss_coef = 1e-2
hparams.add_hparam("moe_gating", "top_2")
# Experts have fixed capacity per batch. We need some extra capacity
# in case gating is not perfectly balanced.
# moe_capacity_factor_* should be set to a value >=1.
hparams.add_hparam("moe_capacity_factor_train", 1.25)
hparams.add_hparam("moe_capacity_factor_eval", 2.0)
hparams.add_hparam("moe_capacity_factor_second_level", 1.0)
# Each expert has a hidden layer with this size.
hparams.add_hparam("moe_hidden_size", 4096)
# For gating, divide inputs into groups of this size before gating.
# Each group sends the same number of inputs to each expert.
# Ideally, the group size would be the whole batch, but this is expensive
# due to our use of matrix multiplication for reordering.
hparams.add_hparam("moe_group_size", 1024)
# For top_2 gating, whether to impose an additional loss in order to make
# the experts equally used as the second-place expert.
hparams.add_hparam("moe_use_second_place_loss", 0)
# In top_2 gating, policy for whether to use a second-place expert.
# Legal values are:
# "all": always
# "none": never
# "threshold": if gate value > the given threshold
# "random": if gate value > threshold*random_uniform(0,1)
hparams.add_hparam("moe_second_policy_train", "random")
hparams.add_hparam("moe_second_policy_eval", "random")
hparams.add_hparam("moe_second_threshold_train", 0.2)
hparams.add_hparam("moe_second_threshold_eval", 0.2)
|
[
"def",
"set_default_moe_hparams",
"(",
"hparams",
")",
":",
"hparams",
".",
"moe_num_experts",
"=",
"16",
"hparams",
".",
"moe_loss_coef",
"=",
"1e-2",
"hparams",
".",
"add_hparam",
"(",
"\"moe_gating\"",
",",
"\"top_2\"",
")",
"# Experts have fixed capacity per batch. We need some extra capacity",
"# in case gating is not perfectly balanced.",
"# moe_capacity_factor_* should be set to a value >=1.",
"hparams",
".",
"add_hparam",
"(",
"\"moe_capacity_factor_train\"",
",",
"1.25",
")",
"hparams",
".",
"add_hparam",
"(",
"\"moe_capacity_factor_eval\"",
",",
"2.0",
")",
"hparams",
".",
"add_hparam",
"(",
"\"moe_capacity_factor_second_level\"",
",",
"1.0",
")",
"# Each expert has a hidden layer with this size.",
"hparams",
".",
"add_hparam",
"(",
"\"moe_hidden_size\"",
",",
"4096",
")",
"# For gating, divide inputs into groups of this size before gating.",
"# Each group sends the same number of inputs to each expert.",
"# Ideally, the group size would be the whole batch, but this is expensive",
"# due to our use of matrix multiplication for reordering.",
"hparams",
".",
"add_hparam",
"(",
"\"moe_group_size\"",
",",
"1024",
")",
"# For top_2 gating, whether to impose an additional loss in order to make",
"# the experts equally used as the second-place expert.",
"hparams",
".",
"add_hparam",
"(",
"\"moe_use_second_place_loss\"",
",",
"0",
")",
"# In top_2 gating, policy for whether to use a second-place expert.",
"# Legal values are:",
"# \"all\": always",
"# \"none\": never",
"# \"threshold\": if gate value > the given threshold",
"# \"random\": if gate value > threshold*random_uniform(0,1)",
"hparams",
".",
"add_hparam",
"(",
"\"moe_second_policy_train\"",
",",
"\"random\"",
")",
"hparams",
".",
"add_hparam",
"(",
"\"moe_second_policy_eval\"",
",",
"\"random\"",
")",
"hparams",
".",
"add_hparam",
"(",
"\"moe_second_threshold_train\"",
",",
"0.2",
")",
"hparams",
".",
"add_hparam",
"(",
"\"moe_second_threshold_eval\"",
",",
"0.2",
")"
] |
Add necessary hyperparameters for mixture-of-experts.
|
[
"Add",
"necessary",
"hyperparameters",
"for",
"mixture",
"-",
"of",
"-",
"experts",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/moe.py#L613-L643
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/models/research/moe.py
|
_split_into_groups
|
def _split_into_groups(n, max_group_size, mesh_dim_size):
"""Helper function for figuring out how to split a dimensino into groups.
We have a dimension with size n and we want to split it into
two dimensions: n = num_groups * group_size
group_size should be the largest possible value meeting the constraints:
group_size <= max_group_size
(num_groups = n/group_size) is a multiple of mesh_dim_size
Args:
n: an integer
max_group_size: an integer
mesh_dim_size: an integer
Returns:
num_groups: an integer
group_size: an integer
Raises:
ValueError: if n is not a multiple of mesh_dim_size
"""
if n % mesh_dim_size != 0:
raise ValueError(
"n=%d is not a multiple of mesh_dim_size=%d" % (n, mesh_dim_size))
num_groups = max(1, n // max_group_size)
while (num_groups % mesh_dim_size != 0 or n % num_groups != 0):
num_groups += 1
group_size = n // num_groups
tf.logging.info(
"_split_into_groups(n=%d, max_group_size=%d, mesh_dim_size=%d)"
" = (num_groups=%d group_size=%d)" %
(n, max_group_size, mesh_dim_size, num_groups, group_size))
return num_groups, group_size
|
python
|
def _split_into_groups(n, max_group_size, mesh_dim_size):
"""Helper function for figuring out how to split a dimensino into groups.
We have a dimension with size n and we want to split it into
two dimensions: n = num_groups * group_size
group_size should be the largest possible value meeting the constraints:
group_size <= max_group_size
(num_groups = n/group_size) is a multiple of mesh_dim_size
Args:
n: an integer
max_group_size: an integer
mesh_dim_size: an integer
Returns:
num_groups: an integer
group_size: an integer
Raises:
ValueError: if n is not a multiple of mesh_dim_size
"""
if n % mesh_dim_size != 0:
raise ValueError(
"n=%d is not a multiple of mesh_dim_size=%d" % (n, mesh_dim_size))
num_groups = max(1, n // max_group_size)
while (num_groups % mesh_dim_size != 0 or n % num_groups != 0):
num_groups += 1
group_size = n // num_groups
tf.logging.info(
"_split_into_groups(n=%d, max_group_size=%d, mesh_dim_size=%d)"
" = (num_groups=%d group_size=%d)" %
(n, max_group_size, mesh_dim_size, num_groups, group_size))
return num_groups, group_size
|
[
"def",
"_split_into_groups",
"(",
"n",
",",
"max_group_size",
",",
"mesh_dim_size",
")",
":",
"if",
"n",
"%",
"mesh_dim_size",
"!=",
"0",
":",
"raise",
"ValueError",
"(",
"\"n=%d is not a multiple of mesh_dim_size=%d\"",
"%",
"(",
"n",
",",
"mesh_dim_size",
")",
")",
"num_groups",
"=",
"max",
"(",
"1",
",",
"n",
"//",
"max_group_size",
")",
"while",
"(",
"num_groups",
"%",
"mesh_dim_size",
"!=",
"0",
"or",
"n",
"%",
"num_groups",
"!=",
"0",
")",
":",
"num_groups",
"+=",
"1",
"group_size",
"=",
"n",
"//",
"num_groups",
"tf",
".",
"logging",
".",
"info",
"(",
"\"_split_into_groups(n=%d, max_group_size=%d, mesh_dim_size=%d)\"",
"\" = (num_groups=%d group_size=%d)\"",
"%",
"(",
"n",
",",
"max_group_size",
",",
"mesh_dim_size",
",",
"num_groups",
",",
"group_size",
")",
")",
"return",
"num_groups",
",",
"group_size"
] |
Helper function for figuring out how to split a dimensino into groups.
We have a dimension with size n and we want to split it into
two dimensions: n = num_groups * group_size
group_size should be the largest possible value meeting the constraints:
group_size <= max_group_size
(num_groups = n/group_size) is a multiple of mesh_dim_size
Args:
n: an integer
max_group_size: an integer
mesh_dim_size: an integer
Returns:
num_groups: an integer
group_size: an integer
Raises:
ValueError: if n is not a multiple of mesh_dim_size
|
[
"Helper",
"function",
"for",
"figuring",
"out",
"how",
"to",
"split",
"a",
"dimensino",
"into",
"groups",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/models/research/moe.py#L646-L679
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/rl/envs/in_graph_batch_env.py
|
InGraphBatchEnv.reset
|
def reset(self, indices=None):
"""Reset the batch of environments.
Args:
indices: The batch indices of the environments to reset.
Returns:
Batch tensor of the new observations.
"""
return tf.cond(
tf.cast(tf.reduce_sum(indices + 1), tf.bool),
lambda: self._reset_non_empty(indices),
lambda: tf.cast(0, self.observ_dtype))
|
python
|
def reset(self, indices=None):
"""Reset the batch of environments.
Args:
indices: The batch indices of the environments to reset.
Returns:
Batch tensor of the new observations.
"""
return tf.cond(
tf.cast(tf.reduce_sum(indices + 1), tf.bool),
lambda: self._reset_non_empty(indices),
lambda: tf.cast(0, self.observ_dtype))
|
[
"def",
"reset",
"(",
"self",
",",
"indices",
"=",
"None",
")",
":",
"return",
"tf",
".",
"cond",
"(",
"tf",
".",
"cast",
"(",
"tf",
".",
"reduce_sum",
"(",
"indices",
"+",
"1",
")",
",",
"tf",
".",
"bool",
")",
",",
"lambda",
":",
"self",
".",
"_reset_non_empty",
"(",
"indices",
")",
",",
"lambda",
":",
"tf",
".",
"cast",
"(",
"0",
",",
"self",
".",
"observ_dtype",
")",
")"
] |
Reset the batch of environments.
Args:
indices: The batch indices of the environments to reset.
Returns:
Batch tensor of the new observations.
|
[
"Reset",
"the",
"batch",
"of",
"environments",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/rl/envs/in_graph_batch_env.py#L62-L74
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/adafactor.py
|
adafactor_decay_rate_adam
|
def adafactor_decay_rate_adam(beta2):
"""Second-moment decay rate like Adam, subsuming the correction factor.
Args:
beta2: a float between 0 and 1
Returns:
a scalar
"""
t = tf.to_float(tf.train.get_or_create_global_step()) + 1.0
decay = beta2 * (1.0 - tf.pow(beta2, t - 1.0)) / (1.0 - tf.pow(beta2, t))
# decay = tf.cond(tf.equal(t, 1.0), lambda: beta2, lambda: decay)
return decay
|
python
|
def adafactor_decay_rate_adam(beta2):
"""Second-moment decay rate like Adam, subsuming the correction factor.
Args:
beta2: a float between 0 and 1
Returns:
a scalar
"""
t = tf.to_float(tf.train.get_or_create_global_step()) + 1.0
decay = beta2 * (1.0 - tf.pow(beta2, t - 1.0)) / (1.0 - tf.pow(beta2, t))
# decay = tf.cond(tf.equal(t, 1.0), lambda: beta2, lambda: decay)
return decay
|
[
"def",
"adafactor_decay_rate_adam",
"(",
"beta2",
")",
":",
"t",
"=",
"tf",
".",
"to_float",
"(",
"tf",
".",
"train",
".",
"get_or_create_global_step",
"(",
")",
")",
"+",
"1.0",
"decay",
"=",
"beta2",
"*",
"(",
"1.0",
"-",
"tf",
".",
"pow",
"(",
"beta2",
",",
"t",
"-",
"1.0",
")",
")",
"/",
"(",
"1.0",
"-",
"tf",
".",
"pow",
"(",
"beta2",
",",
"t",
")",
")",
"# decay = tf.cond(tf.equal(t, 1.0), lambda: beta2, lambda: decay)",
"return",
"decay"
] |
Second-moment decay rate like Adam, subsuming the correction factor.
Args:
beta2: a float between 0 and 1
Returns:
a scalar
|
[
"Second",
"-",
"moment",
"decay",
"rate",
"like",
"Adam",
"subsuming",
"the",
"correction",
"factor",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/adafactor.py#L289-L300
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/adafactor.py
|
adafactor_optimizer_from_hparams
|
def adafactor_optimizer_from_hparams(hparams, lr):
"""Create an Adafactor optimizer based on model hparams.
Args:
hparams: model hyperparameters
lr: learning rate scalar.
Returns:
an AdafactorOptimizer
Raises:
ValueError: on illegal values
"""
if hparams.optimizer_adafactor_decay_type == "adam":
decay_rate = adafactor_decay_rate_adam(
hparams.optimizer_adafactor_beta2)
elif hparams.optimizer_adafactor_decay_type == "pow":
decay_rate = adafactor_decay_rate_pow(
hparams.optimizer_adafactor_memory_exponent)
else:
raise ValueError("unknown optimizer_adafactor_decay_type")
if hparams.weight_dtype == "bfloat16":
parameter_encoding = quantization.EighthPowerEncoding()
else:
parameter_encoding = None
return AdafactorOptimizer(
multiply_by_parameter_scale=(
hparams.optimizer_adafactor_multiply_by_parameter_scale),
learning_rate=lr,
decay_rate=decay_rate,
beta1=hparams.optimizer_adafactor_beta1,
clipping_threshold=hparams.optimizer_adafactor_clipping_threshold,
factored=hparams.optimizer_adafactor_factored,
simulated_quantize_bits=getattr(
hparams, "simulated_parameter_quantize_bits", 0),
parameter_encoding=parameter_encoding,
use_locking=False,
name="Adafactor")
|
python
|
def adafactor_optimizer_from_hparams(hparams, lr):
"""Create an Adafactor optimizer based on model hparams.
Args:
hparams: model hyperparameters
lr: learning rate scalar.
Returns:
an AdafactorOptimizer
Raises:
ValueError: on illegal values
"""
if hparams.optimizer_adafactor_decay_type == "adam":
decay_rate = adafactor_decay_rate_adam(
hparams.optimizer_adafactor_beta2)
elif hparams.optimizer_adafactor_decay_type == "pow":
decay_rate = adafactor_decay_rate_pow(
hparams.optimizer_adafactor_memory_exponent)
else:
raise ValueError("unknown optimizer_adafactor_decay_type")
if hparams.weight_dtype == "bfloat16":
parameter_encoding = quantization.EighthPowerEncoding()
else:
parameter_encoding = None
return AdafactorOptimizer(
multiply_by_parameter_scale=(
hparams.optimizer_adafactor_multiply_by_parameter_scale),
learning_rate=lr,
decay_rate=decay_rate,
beta1=hparams.optimizer_adafactor_beta1,
clipping_threshold=hparams.optimizer_adafactor_clipping_threshold,
factored=hparams.optimizer_adafactor_factored,
simulated_quantize_bits=getattr(
hparams, "simulated_parameter_quantize_bits", 0),
parameter_encoding=parameter_encoding,
use_locking=False,
name="Adafactor")
|
[
"def",
"adafactor_optimizer_from_hparams",
"(",
"hparams",
",",
"lr",
")",
":",
"if",
"hparams",
".",
"optimizer_adafactor_decay_type",
"==",
"\"adam\"",
":",
"decay_rate",
"=",
"adafactor_decay_rate_adam",
"(",
"hparams",
".",
"optimizer_adafactor_beta2",
")",
"elif",
"hparams",
".",
"optimizer_adafactor_decay_type",
"==",
"\"pow\"",
":",
"decay_rate",
"=",
"adafactor_decay_rate_pow",
"(",
"hparams",
".",
"optimizer_adafactor_memory_exponent",
")",
"else",
":",
"raise",
"ValueError",
"(",
"\"unknown optimizer_adafactor_decay_type\"",
")",
"if",
"hparams",
".",
"weight_dtype",
"==",
"\"bfloat16\"",
":",
"parameter_encoding",
"=",
"quantization",
".",
"EighthPowerEncoding",
"(",
")",
"else",
":",
"parameter_encoding",
"=",
"None",
"return",
"AdafactorOptimizer",
"(",
"multiply_by_parameter_scale",
"=",
"(",
"hparams",
".",
"optimizer_adafactor_multiply_by_parameter_scale",
")",
",",
"learning_rate",
"=",
"lr",
",",
"decay_rate",
"=",
"decay_rate",
",",
"beta1",
"=",
"hparams",
".",
"optimizer_adafactor_beta1",
",",
"clipping_threshold",
"=",
"hparams",
".",
"optimizer_adafactor_clipping_threshold",
",",
"factored",
"=",
"hparams",
".",
"optimizer_adafactor_factored",
",",
"simulated_quantize_bits",
"=",
"getattr",
"(",
"hparams",
",",
"\"simulated_parameter_quantize_bits\"",
",",
"0",
")",
",",
"parameter_encoding",
"=",
"parameter_encoding",
",",
"use_locking",
"=",
"False",
",",
"name",
"=",
"\"Adafactor\"",
")"
] |
Create an Adafactor optimizer based on model hparams.
Args:
hparams: model hyperparameters
lr: learning rate scalar.
Returns:
an AdafactorOptimizer
Raises:
ValueError: on illegal values
|
[
"Create",
"an",
"Adafactor",
"optimizer",
"based",
"on",
"model",
"hparams",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/adafactor.py#L318-L353
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
_nargs_validator
|
def _nargs_validator(nargs, message):
"""Makes validator for function to ensure it takes nargs args."""
if message is None:
message = "Registered function must take exactly %d arguments" % nargs
def f(key, value):
del key
spec = inspect.getfullargspec(value)
if (len(spec.args) != nargs or spec.varargs is not None or
spec.varkw is not None):
raise ValueError(message)
return f
|
python
|
def _nargs_validator(nargs, message):
"""Makes validator for function to ensure it takes nargs args."""
if message is None:
message = "Registered function must take exactly %d arguments" % nargs
def f(key, value):
del key
spec = inspect.getfullargspec(value)
if (len(spec.args) != nargs or spec.varargs is not None or
spec.varkw is not None):
raise ValueError(message)
return f
|
[
"def",
"_nargs_validator",
"(",
"nargs",
",",
"message",
")",
":",
"if",
"message",
"is",
"None",
":",
"message",
"=",
"\"Registered function must take exactly %d arguments\"",
"%",
"nargs",
"def",
"f",
"(",
"key",
",",
"value",
")",
":",
"del",
"key",
"spec",
"=",
"inspect",
".",
"getfullargspec",
"(",
"value",
")",
"if",
"(",
"len",
"(",
"spec",
".",
"args",
")",
"!=",
"nargs",
"or",
"spec",
".",
"varargs",
"is",
"not",
"None",
"or",
"spec",
".",
"varkw",
"is",
"not",
"None",
")",
":",
"raise",
"ValueError",
"(",
"message",
")",
"return",
"f"
] |
Makes validator for function to ensure it takes nargs args.
|
[
"Makes",
"validator",
"for",
"function",
"to",
"ensure",
"it",
"takes",
"nargs",
"args",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L287-L299
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
parse_problem_name
|
def parse_problem_name(name):
"""Determines if problem_name specifies a copy and/or reversal.
Args:
name: str, problem name, possibly with suffixes.
Returns:
ProblemSpec: namedtuple with ["base_name", "was_reversed", "was_copy"]
Raises:
ValueError if name contains multiple suffixes of the same type
('_rev' or '_copy'). One of each is ok.
"""
# Recursively strip tags until we reach a base name.
if name.endswith("_rev"):
base, was_reversed, was_copy = parse_problem_name(name[:-4])
if was_reversed:
# duplicate rev
raise ValueError(
"Invalid problem name %s: multiple '_rev' instances" % name)
return ProblemSpec(base, True, was_copy)
elif name.endswith("_copy"):
base, was_reversed, was_copy = parse_problem_name(name[:-5])
if was_copy:
raise ValueError(
"Invalid problem_name %s: multiple '_copy' instances" % name)
return ProblemSpec(base, was_reversed, True)
else:
return ProblemSpec(name, False, False)
|
python
|
def parse_problem_name(name):
"""Determines if problem_name specifies a copy and/or reversal.
Args:
name: str, problem name, possibly with suffixes.
Returns:
ProblemSpec: namedtuple with ["base_name", "was_reversed", "was_copy"]
Raises:
ValueError if name contains multiple suffixes of the same type
('_rev' or '_copy'). One of each is ok.
"""
# Recursively strip tags until we reach a base name.
if name.endswith("_rev"):
base, was_reversed, was_copy = parse_problem_name(name[:-4])
if was_reversed:
# duplicate rev
raise ValueError(
"Invalid problem name %s: multiple '_rev' instances" % name)
return ProblemSpec(base, True, was_copy)
elif name.endswith("_copy"):
base, was_reversed, was_copy = parse_problem_name(name[:-5])
if was_copy:
raise ValueError(
"Invalid problem_name %s: multiple '_copy' instances" % name)
return ProblemSpec(base, was_reversed, True)
else:
return ProblemSpec(name, False, False)
|
[
"def",
"parse_problem_name",
"(",
"name",
")",
":",
"# Recursively strip tags until we reach a base name.",
"if",
"name",
".",
"endswith",
"(",
"\"_rev\"",
")",
":",
"base",
",",
"was_reversed",
",",
"was_copy",
"=",
"parse_problem_name",
"(",
"name",
"[",
":",
"-",
"4",
"]",
")",
"if",
"was_reversed",
":",
"# duplicate rev",
"raise",
"ValueError",
"(",
"\"Invalid problem name %s: multiple '_rev' instances\"",
"%",
"name",
")",
"return",
"ProblemSpec",
"(",
"base",
",",
"True",
",",
"was_copy",
")",
"elif",
"name",
".",
"endswith",
"(",
"\"_copy\"",
")",
":",
"base",
",",
"was_reversed",
",",
"was_copy",
"=",
"parse_problem_name",
"(",
"name",
"[",
":",
"-",
"5",
"]",
")",
"if",
"was_copy",
":",
"raise",
"ValueError",
"(",
"\"Invalid problem_name %s: multiple '_copy' instances\"",
"%",
"name",
")",
"return",
"ProblemSpec",
"(",
"base",
",",
"was_reversed",
",",
"True",
")",
"else",
":",
"return",
"ProblemSpec",
"(",
"name",
",",
"False",
",",
"False",
")"
] |
Determines if problem_name specifies a copy and/or reversal.
Args:
name: str, problem name, possibly with suffixes.
Returns:
ProblemSpec: namedtuple with ["base_name", "was_reversed", "was_copy"]
Raises:
ValueError if name contains multiple suffixes of the same type
('_rev' or '_copy'). One of each is ok.
|
[
"Determines",
"if",
"problem_name",
"specifies",
"a",
"copy",
"and",
"/",
"or",
"reversal",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L306-L334
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
get_problem_name
|
def get_problem_name(base_name, was_reversed=False, was_copy=False):
"""Construct a problem name from base and reversed/copy options.
Inverse of `parse_problem_name`.
Args:
base_name: base problem name. Should not end in "_rev" or "_copy"
was_reversed: if the problem is to be reversed
was_copy: if the problem is to be copied
Returns:
string name consistent with use with `parse_problem_name`.
Raises:
ValueError if `base_name` ends with "_rev" or "_copy"
"""
if any(base_name.endswith(suffix) for suffix in ("_rev", "_copy")):
raise ValueError("`base_name` cannot end in '_rev' or '_copy'")
name = base_name
if was_copy:
name = "%s_copy" % name
if was_reversed:
name = "%s_rev" % name
return name
|
python
|
def get_problem_name(base_name, was_reversed=False, was_copy=False):
"""Construct a problem name from base and reversed/copy options.
Inverse of `parse_problem_name`.
Args:
base_name: base problem name. Should not end in "_rev" or "_copy"
was_reversed: if the problem is to be reversed
was_copy: if the problem is to be copied
Returns:
string name consistent with use with `parse_problem_name`.
Raises:
ValueError if `base_name` ends with "_rev" or "_copy"
"""
if any(base_name.endswith(suffix) for suffix in ("_rev", "_copy")):
raise ValueError("`base_name` cannot end in '_rev' or '_copy'")
name = base_name
if was_copy:
name = "%s_copy" % name
if was_reversed:
name = "%s_rev" % name
return name
|
[
"def",
"get_problem_name",
"(",
"base_name",
",",
"was_reversed",
"=",
"False",
",",
"was_copy",
"=",
"False",
")",
":",
"if",
"any",
"(",
"base_name",
".",
"endswith",
"(",
"suffix",
")",
"for",
"suffix",
"in",
"(",
"\"_rev\"",
",",
"\"_copy\"",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"`base_name` cannot end in '_rev' or '_copy'\"",
")",
"name",
"=",
"base_name",
"if",
"was_copy",
":",
"name",
"=",
"\"%s_copy\"",
"%",
"name",
"if",
"was_reversed",
":",
"name",
"=",
"\"%s_rev\"",
"%",
"name",
"return",
"name"
] |
Construct a problem name from base and reversed/copy options.
Inverse of `parse_problem_name`.
Args:
base_name: base problem name. Should not end in "_rev" or "_copy"
was_reversed: if the problem is to be reversed
was_copy: if the problem is to be copied
Returns:
string name consistent with use with `parse_problem_name`.
Raises:
ValueError if `base_name` ends with "_rev" or "_copy"
|
[
"Construct",
"a",
"problem",
"name",
"from",
"base",
"and",
"reversed",
"/",
"copy",
"options",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L337-L360
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
optimizer
|
def optimizer(name):
"""Get pre-registered optimizer keyed by name.
`name` should be snake case, though SGD -> sgd, RMSProp -> rms_prop and
UpperCamelCase -> snake_case conversions included for legacy support.
Args:
name: name of optimizer used in registration. This should be a snake case
identifier, though others supported for legacy reasons.
Returns:
optimizer
"""
warn_msg = ("Please update `registry.optimizer` callsite "
"(likely due to a `HParams.optimizer` value)")
if name == "SGD":
name = "sgd"
tf.logging.warning("'SGD' optimizer now keyed by 'sgd'. %s" % warn_msg)
elif name == "RMSProp":
name = "rms_prop"
tf.logging.warning(
"'RMSProp' optimizer now keyed by 'rms_prop'. %s" % warn_msg)
else:
snake_name = misc_utils.camelcase_to_snakecase(name)
if name != snake_name:
tf.logging.warning(
"optimizer names now keyed by snake_case names. %s" % warn_msg)
name = snake_name
return Registries.optimizers[name]
|
python
|
def optimizer(name):
"""Get pre-registered optimizer keyed by name.
`name` should be snake case, though SGD -> sgd, RMSProp -> rms_prop and
UpperCamelCase -> snake_case conversions included for legacy support.
Args:
name: name of optimizer used in registration. This should be a snake case
identifier, though others supported for legacy reasons.
Returns:
optimizer
"""
warn_msg = ("Please update `registry.optimizer` callsite "
"(likely due to a `HParams.optimizer` value)")
if name == "SGD":
name = "sgd"
tf.logging.warning("'SGD' optimizer now keyed by 'sgd'. %s" % warn_msg)
elif name == "RMSProp":
name = "rms_prop"
tf.logging.warning(
"'RMSProp' optimizer now keyed by 'rms_prop'. %s" % warn_msg)
else:
snake_name = misc_utils.camelcase_to_snakecase(name)
if name != snake_name:
tf.logging.warning(
"optimizer names now keyed by snake_case names. %s" % warn_msg)
name = snake_name
return Registries.optimizers[name]
|
[
"def",
"optimizer",
"(",
"name",
")",
":",
"warn_msg",
"=",
"(",
"\"Please update `registry.optimizer` callsite \"",
"\"(likely due to a `HParams.optimizer` value)\"",
")",
"if",
"name",
"==",
"\"SGD\"",
":",
"name",
"=",
"\"sgd\"",
"tf",
".",
"logging",
".",
"warning",
"(",
"\"'SGD' optimizer now keyed by 'sgd'. %s\"",
"%",
"warn_msg",
")",
"elif",
"name",
"==",
"\"RMSProp\"",
":",
"name",
"=",
"\"rms_prop\"",
"tf",
".",
"logging",
".",
"warning",
"(",
"\"'RMSProp' optimizer now keyed by 'rms_prop'. %s\"",
"%",
"warn_msg",
")",
"else",
":",
"snake_name",
"=",
"misc_utils",
".",
"camelcase_to_snakecase",
"(",
"name",
")",
"if",
"name",
"!=",
"snake_name",
":",
"tf",
".",
"logging",
".",
"warning",
"(",
"\"optimizer names now keyed by snake_case names. %s\"",
"%",
"warn_msg",
")",
"name",
"=",
"snake_name",
"return",
"Registries",
".",
"optimizers",
"[",
"name",
"]"
] |
Get pre-registered optimizer keyed by name.
`name` should be snake case, though SGD -> sgd, RMSProp -> rms_prop and
UpperCamelCase -> snake_case conversions included for legacy support.
Args:
name: name of optimizer used in registration. This should be a snake case
identifier, though others supported for legacy reasons.
Returns:
optimizer
|
[
"Get",
"pre",
"-",
"registered",
"optimizer",
"keyed",
"by",
"name",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L435-L463
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
problem
|
def problem(problem_name, **kwargs):
"""Get possibly copied/reversed problem in `base_registry` or `env_registry`.
Args:
problem_name: string problem name. See `parse_problem_name`.
**kwargs: forwarded to env problem's initialize method.
Returns:
possibly reversed/copied version of base problem registered in the given
registry.
"""
spec = parse_problem_name(problem_name)
try:
return Registries.problems[spec.base_name](
was_copy=spec.was_copy, was_reversed=spec.was_reversed)
except KeyError:
# If name is not found in base problems then try creating an env problem
return env_problem(problem_name, **kwargs)
|
python
|
def problem(problem_name, **kwargs):
"""Get possibly copied/reversed problem in `base_registry` or `env_registry`.
Args:
problem_name: string problem name. See `parse_problem_name`.
**kwargs: forwarded to env problem's initialize method.
Returns:
possibly reversed/copied version of base problem registered in the given
registry.
"""
spec = parse_problem_name(problem_name)
try:
return Registries.problems[spec.base_name](
was_copy=spec.was_copy, was_reversed=spec.was_reversed)
except KeyError:
# If name is not found in base problems then try creating an env problem
return env_problem(problem_name, **kwargs)
|
[
"def",
"problem",
"(",
"problem_name",
",",
"*",
"*",
"kwargs",
")",
":",
"spec",
"=",
"parse_problem_name",
"(",
"problem_name",
")",
"try",
":",
"return",
"Registries",
".",
"problems",
"[",
"spec",
".",
"base_name",
"]",
"(",
"was_copy",
"=",
"spec",
".",
"was_copy",
",",
"was_reversed",
"=",
"spec",
".",
"was_reversed",
")",
"except",
"KeyError",
":",
"# If name is not found in base problems then try creating an env problem",
"return",
"env_problem",
"(",
"problem_name",
",",
"*",
"*",
"kwargs",
")"
] |
Get possibly copied/reversed problem in `base_registry` or `env_registry`.
Args:
problem_name: string problem name. See `parse_problem_name`.
**kwargs: forwarded to env problem's initialize method.
Returns:
possibly reversed/copied version of base problem registered in the given
registry.
|
[
"Get",
"possibly",
"copied",
"/",
"reversed",
"problem",
"in",
"base_registry",
"or",
"env_registry",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L496-L513
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
env_problem
|
def env_problem(env_problem_name, **kwargs):
"""Get and initialize the `EnvProblem` with the given name and batch size.
Args:
env_problem_name: string name of the registered env problem.
**kwargs: forwarded to env problem's initialize method.
Returns:
an initialized EnvProblem with the given batch size.
"""
ep_cls = Registries.env_problems[env_problem_name]
ep = ep_cls()
ep.initialize(**kwargs)
return ep
|
python
|
def env_problem(env_problem_name, **kwargs):
"""Get and initialize the `EnvProblem` with the given name and batch size.
Args:
env_problem_name: string name of the registered env problem.
**kwargs: forwarded to env problem's initialize method.
Returns:
an initialized EnvProblem with the given batch size.
"""
ep_cls = Registries.env_problems[env_problem_name]
ep = ep_cls()
ep.initialize(**kwargs)
return ep
|
[
"def",
"env_problem",
"(",
"env_problem_name",
",",
"*",
"*",
"kwargs",
")",
":",
"ep_cls",
"=",
"Registries",
".",
"env_problems",
"[",
"env_problem_name",
"]",
"ep",
"=",
"ep_cls",
"(",
")",
"ep",
".",
"initialize",
"(",
"*",
"*",
"kwargs",
")",
"return",
"ep"
] |
Get and initialize the `EnvProblem` with the given name and batch size.
Args:
env_problem_name: string name of the registered env problem.
**kwargs: forwarded to env problem's initialize method.
Returns:
an initialized EnvProblem with the given batch size.
|
[
"Get",
"and",
"initialize",
"the",
"EnvProblem",
"with",
"the",
"given",
"name",
"and",
"batch",
"size",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L516-L530
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
display_list_by_prefix
|
def display_list_by_prefix(names_list, starting_spaces=0):
"""Creates a help string for names_list grouped by prefix."""
cur_prefix, result_lines = None, []
space = " " * starting_spaces
for name in sorted(names_list):
split = name.split("_", 1)
prefix = split[0]
if cur_prefix != prefix:
result_lines.append(space + prefix + ":")
cur_prefix = prefix
result_lines.append(space + " * " + name)
return "\n".join(result_lines)
|
python
|
def display_list_by_prefix(names_list, starting_spaces=0):
"""Creates a help string for names_list grouped by prefix."""
cur_prefix, result_lines = None, []
space = " " * starting_spaces
for name in sorted(names_list):
split = name.split("_", 1)
prefix = split[0]
if cur_prefix != prefix:
result_lines.append(space + prefix + ":")
cur_prefix = prefix
result_lines.append(space + " * " + name)
return "\n".join(result_lines)
|
[
"def",
"display_list_by_prefix",
"(",
"names_list",
",",
"starting_spaces",
"=",
"0",
")",
":",
"cur_prefix",
",",
"result_lines",
"=",
"None",
",",
"[",
"]",
"space",
"=",
"\" \"",
"*",
"starting_spaces",
"for",
"name",
"in",
"sorted",
"(",
"names_list",
")",
":",
"split",
"=",
"name",
".",
"split",
"(",
"\"_\"",
",",
"1",
")",
"prefix",
"=",
"split",
"[",
"0",
"]",
"if",
"cur_prefix",
"!=",
"prefix",
":",
"result_lines",
".",
"append",
"(",
"space",
"+",
"prefix",
"+",
"\":\"",
")",
"cur_prefix",
"=",
"prefix",
"result_lines",
".",
"append",
"(",
"space",
"+",
"\" * \"",
"+",
"name",
")",
"return",
"\"\\n\"",
".",
"join",
"(",
"result_lines",
")"
] |
Creates a help string for names_list grouped by prefix.
|
[
"Creates",
"a",
"help",
"string",
"for",
"names_list",
"grouped",
"by",
"prefix",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L557-L568
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
help_string
|
def help_string():
"""Generate help string with contents of registry."""
help_str = """
Registry contents:
------------------
Models:
%s
HParams:
%s
RangedHParams:
%s
Problems:
%s
Optimizers:
%s
Attacks:
%s
Attack HParams:
%s
Pruning HParams:
%s
Pruning Strategies:
%s
Env Problems:
%s
"""
lists = tuple(
display_list_by_prefix(entries, starting_spaces=4) for entries in [ # pylint: disable=g-complex-comprehension
list_models(),
list_hparams(),
list_ranged_hparams(),
list_base_problems(),
list_optimizers(),
list_attacks(),
list_attack_params(),
list_pruning_params(),
list_pruning_strategies(),
list_env_problems(),
])
return help_str % lists
|
python
|
def help_string():
"""Generate help string with contents of registry."""
help_str = """
Registry contents:
------------------
Models:
%s
HParams:
%s
RangedHParams:
%s
Problems:
%s
Optimizers:
%s
Attacks:
%s
Attack HParams:
%s
Pruning HParams:
%s
Pruning Strategies:
%s
Env Problems:
%s
"""
lists = tuple(
display_list_by_prefix(entries, starting_spaces=4) for entries in [ # pylint: disable=g-complex-comprehension
list_models(),
list_hparams(),
list_ranged_hparams(),
list_base_problems(),
list_optimizers(),
list_attacks(),
list_attack_params(),
list_pruning_params(),
list_pruning_strategies(),
list_env_problems(),
])
return help_str % lists
|
[
"def",
"help_string",
"(",
")",
":",
"help_str",
"=",
"\"\"\"\nRegistry contents:\n------------------\n\n Models:\n%s\n\n HParams:\n%s\n\n RangedHParams:\n%s\n\n Problems:\n%s\n\n Optimizers:\n%s\n\n Attacks:\n%s\n\n Attack HParams:\n%s\n\n Pruning HParams:\n%s\n\n Pruning Strategies:\n%s\n\n Env Problems:\n%s\n\"\"\"",
"lists",
"=",
"tuple",
"(",
"display_list_by_prefix",
"(",
"entries",
",",
"starting_spaces",
"=",
"4",
")",
"for",
"entries",
"in",
"[",
"# pylint: disable=g-complex-comprehension",
"list_models",
"(",
")",
",",
"list_hparams",
"(",
")",
",",
"list_ranged_hparams",
"(",
")",
",",
"list_base_problems",
"(",
")",
",",
"list_optimizers",
"(",
")",
",",
"list_attacks",
"(",
")",
",",
"list_attack_params",
"(",
")",
",",
"list_pruning_params",
"(",
")",
",",
"list_pruning_strategies",
"(",
")",
",",
"list_env_problems",
"(",
")",
",",
"]",
")",
"return",
"help_str",
"%",
"lists"
] |
Generate help string with contents of registry.
|
[
"Generate",
"help",
"string",
"with",
"contents",
"of",
"registry",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L571-L620
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
Registry.validate
|
def validate(self, key, value):
"""Validation function run before setting. Uses function from __init__."""
if self._validator is not None:
self._validator(key, value)
|
python
|
def validate(self, key, value):
"""Validation function run before setting. Uses function from __init__."""
if self._validator is not None:
self._validator(key, value)
|
[
"def",
"validate",
"(",
"self",
",",
"key",
",",
"value",
")",
":",
"if",
"self",
".",
"_validator",
"is",
"not",
"None",
":",
"self",
".",
"_validator",
"(",
"key",
",",
"value",
")"
] |
Validation function run before setting. Uses function from __init__.
|
[
"Validation",
"function",
"run",
"before",
"setting",
".",
"Uses",
"function",
"from",
"__init__",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L169-L172
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
Registry.on_set
|
def on_set(self, key, value):
"""Callback called on successful set. Uses function from __init__."""
if self._on_set is not None:
self._on_set(key, value)
|
python
|
def on_set(self, key, value):
"""Callback called on successful set. Uses function from __init__."""
if self._on_set is not None:
self._on_set(key, value)
|
[
"def",
"on_set",
"(",
"self",
",",
"key",
",",
"value",
")",
":",
"if",
"self",
".",
"_on_set",
"is",
"not",
"None",
":",
"self",
".",
"_on_set",
"(",
"key",
",",
"value",
")"
] |
Callback called on successful set. Uses function from __init__.
|
[
"Callback",
"called",
"on",
"successful",
"set",
".",
"Uses",
"function",
"from",
"__init__",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L174-L177
|
train
|
tensorflow/tensor2tensor
|
tensor2tensor/utils/registry.py
|
Registry.register
|
def register(self, key_or_value=None):
"""Decorator to register a function, or registration itself.
This is primarily intended for use as a decorator, either with or without
a key/parentheses.
```python
@my_registry.register('key1')
def value_fn(x, y, z):
pass
@my_registry.register()
def another_fn(x, y):
pass
@my_registry.register
def third_func():
pass
```
Note if key_or_value is provided as a non-callable, registration only
occurs once the returned callback is called with a callable as its only
argument.
```python
callback = my_registry.register('different_key')
'different_key' in my_registry # False
callback(lambda (x, y): x + y)
'different_key' in my_registry # True
```
Args:
key_or_value (optional): key to access the registered value with, or the
function itself. If `None` (default), `self.default_key` will be called
on `value` once the returned callback is called with `value` as the only
arg. If `key_or_value` is itself callable, it is assumed to be the value
and the key is given by `self.default_key(key)`.
Returns:
decorated callback, or callback generated a decorated function.
"""
def decorator(value, key):
self[key] = value
return value
# Handle if decorator was used without parens
if callable(key_or_value):
return decorator(value=key_or_value, key=None)
else:
return lambda value: decorator(value, key=key_or_value)
|
python
|
def register(self, key_or_value=None):
"""Decorator to register a function, or registration itself.
This is primarily intended for use as a decorator, either with or without
a key/parentheses.
```python
@my_registry.register('key1')
def value_fn(x, y, z):
pass
@my_registry.register()
def another_fn(x, y):
pass
@my_registry.register
def third_func():
pass
```
Note if key_or_value is provided as a non-callable, registration only
occurs once the returned callback is called with a callable as its only
argument.
```python
callback = my_registry.register('different_key')
'different_key' in my_registry # False
callback(lambda (x, y): x + y)
'different_key' in my_registry # True
```
Args:
key_or_value (optional): key to access the registered value with, or the
function itself. If `None` (default), `self.default_key` will be called
on `value` once the returned callback is called with `value` as the only
arg. If `key_or_value` is itself callable, it is assumed to be the value
and the key is given by `self.default_key(key)`.
Returns:
decorated callback, or callback generated a decorated function.
"""
def decorator(value, key):
self[key] = value
return value
# Handle if decorator was used without parens
if callable(key_or_value):
return decorator(value=key_or_value, key=None)
else:
return lambda value: decorator(value, key=key_or_value)
|
[
"def",
"register",
"(",
"self",
",",
"key_or_value",
"=",
"None",
")",
":",
"def",
"decorator",
"(",
"value",
",",
"key",
")",
":",
"self",
"[",
"key",
"]",
"=",
"value",
"return",
"value",
"# Handle if decorator was used without parens",
"if",
"callable",
"(",
"key_or_value",
")",
":",
"return",
"decorator",
"(",
"value",
"=",
"key_or_value",
",",
"key",
"=",
"None",
")",
"else",
":",
"return",
"lambda",
"value",
":",
"decorator",
"(",
"value",
",",
"key",
"=",
"key_or_value",
")"
] |
Decorator to register a function, or registration itself.
This is primarily intended for use as a decorator, either with or without
a key/parentheses.
```python
@my_registry.register('key1')
def value_fn(x, y, z):
pass
@my_registry.register()
def another_fn(x, y):
pass
@my_registry.register
def third_func():
pass
```
Note if key_or_value is provided as a non-callable, registration only
occurs once the returned callback is called with a callable as its only
argument.
```python
callback = my_registry.register('different_key')
'different_key' in my_registry # False
callback(lambda (x, y): x + y)
'different_key' in my_registry # True
```
Args:
key_or_value (optional): key to access the registered value with, or the
function itself. If `None` (default), `self.default_key` will be called
on `value` once the returned callback is called with `value` as the only
arg. If `key_or_value` is itself callable, it is assumed to be the value
and the key is given by `self.default_key(key)`.
Returns:
decorated callback, or callback generated a decorated function.
|
[
"Decorator",
"to",
"register",
"a",
"function",
"or",
"registration",
"itself",
"."
] |
272500b6efe353aeb638d2745ed56e519462ca31
|
https://github.com/tensorflow/tensor2tensor/blob/272500b6efe353aeb638d2745ed56e519462ca31/tensor2tensor/utils/registry.py#L201-L249
|
train
|
Microsoft/LightGBM
|
helpers/check_dynamic_dependencies.py
|
check_dependicies
|
def check_dependicies(objdump_string):
"""Check the dynamic symbol versions.
Parameters
----------
objdump_string : string
The dynamic symbol table entries of the file (result of `objdump -T` command).
"""
GLIBC_version = re.compile(r'0{16}[ \t]+GLIBC_(\d{1,2})[.](\d{1,3})[.]?\d{,3}[ \t]+')
versions = GLIBC_version.findall(objdump_string)
assert len(versions) > 1
for major, minor in versions:
assert int(major) <= 2
assert int(minor) <= 14
GLIBCXX_version = re.compile(r'0{16}[ \t]+GLIBCXX_(\d{1,2})[.](\d{1,2})[.]?(\d{,3})[ \t]+')
versions = GLIBCXX_version.findall(objdump_string)
assert len(versions) > 1
for major, minor, patch in versions:
assert int(major) == 3
assert int(minor) == 4
assert patch == '' or int(patch) <= 19
GOMP_version = re.compile(r'0{16}[ \t]+G?OMP_(\d{1,2})[.](\d{1,2})[.]?\d{,3}[ \t]+')
versions = GOMP_version.findall(objdump_string)
assert len(versions) > 1
for major, minor in versions:
assert int(major) == 1
assert int(minor) == 0
|
python
|
def check_dependicies(objdump_string):
"""Check the dynamic symbol versions.
Parameters
----------
objdump_string : string
The dynamic symbol table entries of the file (result of `objdump -T` command).
"""
GLIBC_version = re.compile(r'0{16}[ \t]+GLIBC_(\d{1,2})[.](\d{1,3})[.]?\d{,3}[ \t]+')
versions = GLIBC_version.findall(objdump_string)
assert len(versions) > 1
for major, minor in versions:
assert int(major) <= 2
assert int(minor) <= 14
GLIBCXX_version = re.compile(r'0{16}[ \t]+GLIBCXX_(\d{1,2})[.](\d{1,2})[.]?(\d{,3})[ \t]+')
versions = GLIBCXX_version.findall(objdump_string)
assert len(versions) > 1
for major, minor, patch in versions:
assert int(major) == 3
assert int(minor) == 4
assert patch == '' or int(patch) <= 19
GOMP_version = re.compile(r'0{16}[ \t]+G?OMP_(\d{1,2})[.](\d{1,2})[.]?\d{,3}[ \t]+')
versions = GOMP_version.findall(objdump_string)
assert len(versions) > 1
for major, minor in versions:
assert int(major) == 1
assert int(minor) == 0
|
[
"def",
"check_dependicies",
"(",
"objdump_string",
")",
":",
"GLIBC_version",
"=",
"re",
".",
"compile",
"(",
"r'0{16}[ \\t]+GLIBC_(\\d{1,2})[.](\\d{1,3})[.]?\\d{,3}[ \\t]+'",
")",
"versions",
"=",
"GLIBC_version",
".",
"findall",
"(",
"objdump_string",
")",
"assert",
"len",
"(",
"versions",
")",
">",
"1",
"for",
"major",
",",
"minor",
"in",
"versions",
":",
"assert",
"int",
"(",
"major",
")",
"<=",
"2",
"assert",
"int",
"(",
"minor",
")",
"<=",
"14",
"GLIBCXX_version",
"=",
"re",
".",
"compile",
"(",
"r'0{16}[ \\t]+GLIBCXX_(\\d{1,2})[.](\\d{1,2})[.]?(\\d{,3})[ \\t]+'",
")",
"versions",
"=",
"GLIBCXX_version",
".",
"findall",
"(",
"objdump_string",
")",
"assert",
"len",
"(",
"versions",
")",
">",
"1",
"for",
"major",
",",
"minor",
",",
"patch",
"in",
"versions",
":",
"assert",
"int",
"(",
"major",
")",
"==",
"3",
"assert",
"int",
"(",
"minor",
")",
"==",
"4",
"assert",
"patch",
"==",
"''",
"or",
"int",
"(",
"patch",
")",
"<=",
"19",
"GOMP_version",
"=",
"re",
".",
"compile",
"(",
"r'0{16}[ \\t]+G?OMP_(\\d{1,2})[.](\\d{1,2})[.]?\\d{,3}[ \\t]+'",
")",
"versions",
"=",
"GOMP_version",
".",
"findall",
"(",
"objdump_string",
")",
"assert",
"len",
"(",
"versions",
")",
">",
"1",
"for",
"major",
",",
"minor",
"in",
"versions",
":",
"assert",
"int",
"(",
"major",
")",
"==",
"1",
"assert",
"int",
"(",
"minor",
")",
"==",
"0"
] |
Check the dynamic symbol versions.
Parameters
----------
objdump_string : string
The dynamic symbol table entries of the file (result of `objdump -T` command).
|
[
"Check",
"the",
"dynamic",
"symbol",
"versions",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/check_dynamic_dependencies.py#L10-L38
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
_objective_function_wrapper
|
def _objective_function_wrapper(func):
"""Decorate an objective function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i]
and you should group grad and hess in this way as well.
Parameters
----------
func : callable
Expects a callable with signature ``func(y_true, y_pred)`` or ``func(y_true, y_pred, group):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new objective function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
"""
def inner(preds, dataset):
"""Call passed function with appropriate arguments."""
labels = dataset.get_label()
argc = argc_(func)
if argc == 2:
grad, hess = func(labels, preds)
elif argc == 3:
grad, hess = func(labels, preds, dataset.get_group())
else:
raise TypeError("Self-defined objective function should have 2 or 3 arguments, got %d" % argc)
"""weighted for objective"""
weight = dataset.get_weight()
if weight is not None:
"""only one class"""
if len(weight) == len(grad):
grad = np.multiply(grad, weight)
hess = np.multiply(hess, weight)
else:
num_data = len(weight)
num_class = len(grad) // num_data
if num_class * num_data != len(grad):
raise ValueError("Length of grad and hess should equal to num_class * num_data")
for k in range_(num_class):
for i in range_(num_data):
idx = k * num_data + i
grad[idx] *= weight[i]
hess[idx] *= weight[i]
return grad, hess
return inner
|
python
|
def _objective_function_wrapper(func):
"""Decorate an objective function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i]
and you should group grad and hess in this way as well.
Parameters
----------
func : callable
Expects a callable with signature ``func(y_true, y_pred)`` or ``func(y_true, y_pred, group):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new objective function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
"""
def inner(preds, dataset):
"""Call passed function with appropriate arguments."""
labels = dataset.get_label()
argc = argc_(func)
if argc == 2:
grad, hess = func(labels, preds)
elif argc == 3:
grad, hess = func(labels, preds, dataset.get_group())
else:
raise TypeError("Self-defined objective function should have 2 or 3 arguments, got %d" % argc)
"""weighted for objective"""
weight = dataset.get_weight()
if weight is not None:
"""only one class"""
if len(weight) == len(grad):
grad = np.multiply(grad, weight)
hess = np.multiply(hess, weight)
else:
num_data = len(weight)
num_class = len(grad) // num_data
if num_class * num_data != len(grad):
raise ValueError("Length of grad and hess should equal to num_class * num_data")
for k in range_(num_class):
for i in range_(num_data):
idx = k * num_data + i
grad[idx] *= weight[i]
hess[idx] *= weight[i]
return grad, hess
return inner
|
[
"def",
"_objective_function_wrapper",
"(",
"func",
")",
":",
"def",
"inner",
"(",
"preds",
",",
"dataset",
")",
":",
"\"\"\"Call passed function with appropriate arguments.\"\"\"",
"labels",
"=",
"dataset",
".",
"get_label",
"(",
")",
"argc",
"=",
"argc_",
"(",
"func",
")",
"if",
"argc",
"==",
"2",
":",
"grad",
",",
"hess",
"=",
"func",
"(",
"labels",
",",
"preds",
")",
"elif",
"argc",
"==",
"3",
":",
"grad",
",",
"hess",
"=",
"func",
"(",
"labels",
",",
"preds",
",",
"dataset",
".",
"get_group",
"(",
")",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"Self-defined objective function should have 2 or 3 arguments, got %d\"",
"%",
"argc",
")",
"\"\"\"weighted for objective\"\"\"",
"weight",
"=",
"dataset",
".",
"get_weight",
"(",
")",
"if",
"weight",
"is",
"not",
"None",
":",
"\"\"\"only one class\"\"\"",
"if",
"len",
"(",
"weight",
")",
"==",
"len",
"(",
"grad",
")",
":",
"grad",
"=",
"np",
".",
"multiply",
"(",
"grad",
",",
"weight",
")",
"hess",
"=",
"np",
".",
"multiply",
"(",
"hess",
",",
"weight",
")",
"else",
":",
"num_data",
"=",
"len",
"(",
"weight",
")",
"num_class",
"=",
"len",
"(",
"grad",
")",
"//",
"num_data",
"if",
"num_class",
"*",
"num_data",
"!=",
"len",
"(",
"grad",
")",
":",
"raise",
"ValueError",
"(",
"\"Length of grad and hess should equal to num_class * num_data\"",
")",
"for",
"k",
"in",
"range_",
"(",
"num_class",
")",
":",
"for",
"i",
"in",
"range_",
"(",
"num_data",
")",
":",
"idx",
"=",
"k",
"*",
"num_data",
"+",
"i",
"grad",
"[",
"idx",
"]",
"*=",
"weight",
"[",
"i",
"]",
"hess",
"[",
"idx",
"]",
"*=",
"weight",
"[",
"i",
"]",
"return",
"grad",
",",
"hess",
"return",
"inner"
] |
Decorate an objective function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i]
and you should group grad and hess in this way as well.
Parameters
----------
func : callable
Expects a callable with signature ``func(y_true, y_pred)`` or ``func(y_true, y_pred, group):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new objective function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
|
[
"Decorate",
"an",
"objective",
"function",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L18-L78
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
_eval_function_wrapper
|
def _eval_function_wrapper(func):
"""Decorate an eval function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
Parameters
----------
func : callable
Expects a callable with following signatures:
``func(y_true, y_pred)``,
``func(y_true, y_pred, weight)``
or ``func(y_true, y_pred, weight, group)``
and returns (eval_name->string, eval_result->float, is_bigger_better->bool):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new eval function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
"""
def inner(preds, dataset):
"""Call passed function with appropriate arguments."""
labels = dataset.get_label()
argc = argc_(func)
if argc == 2:
return func(labels, preds)
elif argc == 3:
return func(labels, preds, dataset.get_weight())
elif argc == 4:
return func(labels, preds, dataset.get_weight(), dataset.get_group())
else:
raise TypeError("Self-defined eval function should have 2, 3 or 4 arguments, got %d" % argc)
return inner
|
python
|
def _eval_function_wrapper(func):
"""Decorate an eval function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
Parameters
----------
func : callable
Expects a callable with following signatures:
``func(y_true, y_pred)``,
``func(y_true, y_pred, weight)``
or ``func(y_true, y_pred, weight, group)``
and returns (eval_name->string, eval_result->float, is_bigger_better->bool):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new eval function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
"""
def inner(preds, dataset):
"""Call passed function with appropriate arguments."""
labels = dataset.get_label()
argc = argc_(func)
if argc == 2:
return func(labels, preds)
elif argc == 3:
return func(labels, preds, dataset.get_weight())
elif argc == 4:
return func(labels, preds, dataset.get_weight(), dataset.get_group())
else:
raise TypeError("Self-defined eval function should have 2, 3 or 4 arguments, got %d" % argc)
return inner
|
[
"def",
"_eval_function_wrapper",
"(",
"func",
")",
":",
"def",
"inner",
"(",
"preds",
",",
"dataset",
")",
":",
"\"\"\"Call passed function with appropriate arguments.\"\"\"",
"labels",
"=",
"dataset",
".",
"get_label",
"(",
")",
"argc",
"=",
"argc_",
"(",
"func",
")",
"if",
"argc",
"==",
"2",
":",
"return",
"func",
"(",
"labels",
",",
"preds",
")",
"elif",
"argc",
"==",
"3",
":",
"return",
"func",
"(",
"labels",
",",
"preds",
",",
"dataset",
".",
"get_weight",
"(",
")",
")",
"elif",
"argc",
"==",
"4",
":",
"return",
"func",
"(",
"labels",
",",
"preds",
",",
"dataset",
".",
"get_weight",
"(",
")",
",",
"dataset",
".",
"get_group",
"(",
")",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"Self-defined eval function should have 2, 3 or 4 arguments, got %d\"",
"%",
"argc",
")",
"return",
"inner"
] |
Decorate an eval function.
Note
----
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
Parameters
----------
func : callable
Expects a callable with following signatures:
``func(y_true, y_pred)``,
``func(y_true, y_pred, weight)``
or ``func(y_true, y_pred, weight, group)``
and returns (eval_name->string, eval_result->float, is_bigger_better->bool):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
Returns
-------
new_func : callable
The new eval function as expected by ``lightgbm.engine.train``.
The signature is ``new_func(preds, dataset)``:
preds : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
dataset : Dataset
The training set from which the labels will be extracted using ``dataset.get_label()``.
|
[
"Decorate",
"an",
"eval",
"function",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L81-L130
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMModel.get_params
|
def get_params(self, deep=True):
"""Get parameters for this estimator.
Parameters
----------
deep : bool, optional (default=True)
If True, will return the parameters for this estimator and
contained subobjects that are estimators.
Returns
-------
params : dict
Parameter names mapped to their values.
"""
params = super(LGBMModel, self).get_params(deep=deep)
params.update(self._other_params)
return params
|
python
|
def get_params(self, deep=True):
"""Get parameters for this estimator.
Parameters
----------
deep : bool, optional (default=True)
If True, will return the parameters for this estimator and
contained subobjects that are estimators.
Returns
-------
params : dict
Parameter names mapped to their values.
"""
params = super(LGBMModel, self).get_params(deep=deep)
params.update(self._other_params)
return params
|
[
"def",
"get_params",
"(",
"self",
",",
"deep",
"=",
"True",
")",
":",
"params",
"=",
"super",
"(",
"LGBMModel",
",",
"self",
")",
".",
"get_params",
"(",
"deep",
"=",
"deep",
")",
"params",
".",
"update",
"(",
"self",
".",
"_other_params",
")",
"return",
"params"
] |
Get parameters for this estimator.
Parameters
----------
deep : bool, optional (default=True)
If True, will return the parameters for this estimator and
contained subobjects that are estimators.
Returns
-------
params : dict
Parameter names mapped to their values.
|
[
"Get",
"parameters",
"for",
"this",
"estimator",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L293-L309
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMModel.fit
|
def fit(self, X, y,
sample_weight=None, init_score=None, group=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_class_weight=None, eval_init_score=None, eval_group=None,
eval_metric=None, early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Build a gradient boosting model from the training set (X, y).
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input feature matrix.
y : array-like of shape = [n_samples]
The target values (class labels in classification, real numbers in regression).
sample_weight : array-like of shape = [n_samples] or None, optional (default=None)
Weights of training data.
init_score : array-like of shape = [n_samples] or None, optional (default=None)
Init score of training data.
group : array-like or None, optional (default=None)
Group data of training data.
eval_set : list or None, optional (default=None)
A list of (X, y) tuple pairs to use as validation sets.
eval_names : list of strings or None, optional (default=None)
Names of eval_set.
eval_sample_weight : list of arrays or None, optional (default=None)
Weights of eval data.
eval_class_weight : list or None, optional (default=None)
Class weights of eval data.
eval_init_score : list of arrays or None, optional (default=None)
Init score of eval data.
eval_group : list of arrays or None, optional (default=None)
Group data of eval data.
eval_metric : string, list of strings, callable or None, optional (default=None)
If string, it should be a built-in evaluation metric to use.
If callable, it should be a custom evaluation metric, see note below for more details.
In either case, the ``metric`` from the model parameters will be evaluated and used as well.
Default: 'l2' for LGBMRegressor, 'logloss' for LGBMClassifier, 'ndcg' for LGBMRanker.
early_stopping_rounds : int or None, optional (default=None)
Activates early stopping. The model will train until the validation score stops improving.
Validation score needs to improve at least every ``early_stopping_rounds`` round(s)
to continue training.
Requires at least one validation data and one metric.
If there's more than one, will check all of them. But the training data is ignored anyway.
To check only the first metric you can pass in ``callbacks``
``early_stopping`` callback with ``first_metric_only=True``.
verbose : bool or int, optional (default=True)
Requires at least one evaluation data.
If True, the eval metric on the eval set is printed at each boosting stage.
If int, the eval metric on the eval set is printed at every ``verbose`` boosting stage.
The last boosting stage or the boosting stage found by using ``early_stopping_rounds`` is also printed.
Example
-------
With ``verbose`` = 4 and at least one item in ``eval_set``,
an evaluation metric is printed every 4 (instead of 1) boosting stages.
feature_name : list of strings or 'auto', optional (default='auto')
Feature names.
If 'auto' and data is pandas DataFrame, data columns names are used.
categorical_feature : list of strings or int, or 'auto', optional (default='auto')
Categorical features.
If list of int, interpreted as indices.
If list of strings, interpreted as feature names (need to specify ``feature_name`` as well).
If 'auto' and data is pandas DataFrame, pandas unordered categorical columns are used.
All values in categorical features should be less than int32 max value (2147483647).
Large values could be memory consuming. Consider using consecutive integers starting from zero.
All negative values in categorical features will be treated as missing values.
callbacks : list of callback functions or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
Returns
-------
self : object
Returns self.
Note
----
Custom eval function expects a callable with following signatures:
``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
``func(y_true, y_pred, weight, group)``
and returns (eval_name, eval_result, is_bigger_better) or
list of (eval_name, eval_result, is_bigger_better):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
eval_name : string
The name of evaluation.
eval_result : float
The eval result.
is_bigger_better : bool
Is eval result bigger better, e.g. AUC is bigger_better.
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
"""
if self._objective is None:
if isinstance(self, LGBMRegressor):
self._objective = "regression"
elif isinstance(self, LGBMClassifier):
self._objective = "binary"
elif isinstance(self, LGBMRanker):
self._objective = "lambdarank"
else:
raise ValueError("Unknown LGBMModel type.")
if callable(self._objective):
self._fobj = _objective_function_wrapper(self._objective)
else:
self._fobj = None
evals_result = {}
params = self.get_params()
# user can set verbose with kwargs, it has higher priority
if not any(verbose_alias in params for verbose_alias in ('verbose', 'verbosity')) and self.silent:
params['verbose'] = -1
params.pop('silent', None)
params.pop('importance_type', None)
params.pop('n_estimators', None)
params.pop('class_weight', None)
if self._n_classes is not None and self._n_classes > 2:
params['num_class'] = self._n_classes
if hasattr(self, '_eval_at'):
params['eval_at'] = self._eval_at
params['objective'] = self._objective
if self._fobj:
params['objective'] = 'None' # objective = nullptr for unknown objective
if callable(eval_metric):
feval = _eval_function_wrapper(eval_metric)
else:
feval = None
# register default metric for consistency with callable eval_metric case
original_metric = self._objective if isinstance(self._objective, string_type) else None
if original_metric is None:
# try to deduce from class instance
if isinstance(self, LGBMRegressor):
original_metric = "l2"
elif isinstance(self, LGBMClassifier):
original_metric = "multi_logloss" if self._n_classes > 2 else "binary_logloss"
elif isinstance(self, LGBMRanker):
original_metric = "ndcg"
# overwrite default metric by explicitly set metric
for metric_alias in ['metric', 'metrics', 'metric_types']:
if metric_alias in params:
original_metric = params.pop(metric_alias)
# concatenate metric from params (or default if not provided in params) and eval_metric
original_metric = [original_metric] if isinstance(original_metric, (string_type, type(None))) else original_metric
eval_metric = [eval_metric] if isinstance(eval_metric, (string_type, type(None))) else eval_metric
params['metric'] = set(original_metric + eval_metric)
if not isinstance(X, (DataFrame, DataTable)):
_X, _y = _LGBMCheckXY(X, y, accept_sparse=True, force_all_finite=False, ensure_min_samples=2)
_LGBMCheckConsistentLength(_X, _y, sample_weight)
else:
_X, _y = X, y
if self.class_weight is not None:
class_sample_weight = _LGBMComputeSampleWeight(self.class_weight, y)
if sample_weight is None or len(sample_weight) == 0:
sample_weight = class_sample_weight
else:
sample_weight = np.multiply(sample_weight, class_sample_weight)
self._n_features = _X.shape[1]
def _construct_dataset(X, y, sample_weight, init_score, group, params):
ret = Dataset(X, label=y, weight=sample_weight, group=group, params=params)
return ret.set_init_score(init_score)
train_set = _construct_dataset(_X, _y, sample_weight, init_score, group, params)
valid_sets = []
if eval_set is not None:
def _get_meta_data(collection, i):
if collection is None:
return None
elif isinstance(collection, list):
return collection[i] if len(collection) > i else None
elif isinstance(collection, dict):
return collection.get(i, None)
else:
raise TypeError('eval_sample_weight, eval_class_weight, eval_init_score, and eval_group '
'should be dict or list')
if isinstance(eval_set, tuple):
eval_set = [eval_set]
for i, valid_data in enumerate(eval_set):
# reduce cost for prediction training data
if valid_data[0] is X and valid_data[1] is y:
valid_set = train_set
else:
valid_weight = _get_meta_data(eval_sample_weight, i)
if _get_meta_data(eval_class_weight, i) is not None:
valid_class_sample_weight = _LGBMComputeSampleWeight(_get_meta_data(eval_class_weight, i),
valid_data[1])
if valid_weight is None or len(valid_weight) == 0:
valid_weight = valid_class_sample_weight
else:
valid_weight = np.multiply(valid_weight, valid_class_sample_weight)
valid_init_score = _get_meta_data(eval_init_score, i)
valid_group = _get_meta_data(eval_group, i)
valid_set = _construct_dataset(valid_data[0], valid_data[1],
valid_weight, valid_init_score, valid_group, params)
valid_sets.append(valid_set)
self._Booster = train(params, train_set,
self.n_estimators, valid_sets=valid_sets, valid_names=eval_names,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, fobj=self._fobj, feval=feval,
verbose_eval=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
if evals_result:
self._evals_result = evals_result
if early_stopping_rounds is not None:
self._best_iteration = self._Booster.best_iteration
self._best_score = self._Booster.best_score
# free dataset
self.booster_.free_dataset()
del train_set, valid_sets
return self
|
python
|
def fit(self, X, y,
sample_weight=None, init_score=None, group=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_class_weight=None, eval_init_score=None, eval_group=None,
eval_metric=None, early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Build a gradient boosting model from the training set (X, y).
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input feature matrix.
y : array-like of shape = [n_samples]
The target values (class labels in classification, real numbers in regression).
sample_weight : array-like of shape = [n_samples] or None, optional (default=None)
Weights of training data.
init_score : array-like of shape = [n_samples] or None, optional (default=None)
Init score of training data.
group : array-like or None, optional (default=None)
Group data of training data.
eval_set : list or None, optional (default=None)
A list of (X, y) tuple pairs to use as validation sets.
eval_names : list of strings or None, optional (default=None)
Names of eval_set.
eval_sample_weight : list of arrays or None, optional (default=None)
Weights of eval data.
eval_class_weight : list or None, optional (default=None)
Class weights of eval data.
eval_init_score : list of arrays or None, optional (default=None)
Init score of eval data.
eval_group : list of arrays or None, optional (default=None)
Group data of eval data.
eval_metric : string, list of strings, callable or None, optional (default=None)
If string, it should be a built-in evaluation metric to use.
If callable, it should be a custom evaluation metric, see note below for more details.
In either case, the ``metric`` from the model parameters will be evaluated and used as well.
Default: 'l2' for LGBMRegressor, 'logloss' for LGBMClassifier, 'ndcg' for LGBMRanker.
early_stopping_rounds : int or None, optional (default=None)
Activates early stopping. The model will train until the validation score stops improving.
Validation score needs to improve at least every ``early_stopping_rounds`` round(s)
to continue training.
Requires at least one validation data and one metric.
If there's more than one, will check all of them. But the training data is ignored anyway.
To check only the first metric you can pass in ``callbacks``
``early_stopping`` callback with ``first_metric_only=True``.
verbose : bool or int, optional (default=True)
Requires at least one evaluation data.
If True, the eval metric on the eval set is printed at each boosting stage.
If int, the eval metric on the eval set is printed at every ``verbose`` boosting stage.
The last boosting stage or the boosting stage found by using ``early_stopping_rounds`` is also printed.
Example
-------
With ``verbose`` = 4 and at least one item in ``eval_set``,
an evaluation metric is printed every 4 (instead of 1) boosting stages.
feature_name : list of strings or 'auto', optional (default='auto')
Feature names.
If 'auto' and data is pandas DataFrame, data columns names are used.
categorical_feature : list of strings or int, or 'auto', optional (default='auto')
Categorical features.
If list of int, interpreted as indices.
If list of strings, interpreted as feature names (need to specify ``feature_name`` as well).
If 'auto' and data is pandas DataFrame, pandas unordered categorical columns are used.
All values in categorical features should be less than int32 max value (2147483647).
Large values could be memory consuming. Consider using consecutive integers starting from zero.
All negative values in categorical features will be treated as missing values.
callbacks : list of callback functions or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
Returns
-------
self : object
Returns self.
Note
----
Custom eval function expects a callable with following signatures:
``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
``func(y_true, y_pred, weight, group)``
and returns (eval_name, eval_result, is_bigger_better) or
list of (eval_name, eval_result, is_bigger_better):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
eval_name : string
The name of evaluation.
eval_result : float
The eval result.
is_bigger_better : bool
Is eval result bigger better, e.g. AUC is bigger_better.
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
"""
if self._objective is None:
if isinstance(self, LGBMRegressor):
self._objective = "regression"
elif isinstance(self, LGBMClassifier):
self._objective = "binary"
elif isinstance(self, LGBMRanker):
self._objective = "lambdarank"
else:
raise ValueError("Unknown LGBMModel type.")
if callable(self._objective):
self._fobj = _objective_function_wrapper(self._objective)
else:
self._fobj = None
evals_result = {}
params = self.get_params()
# user can set verbose with kwargs, it has higher priority
if not any(verbose_alias in params for verbose_alias in ('verbose', 'verbosity')) and self.silent:
params['verbose'] = -1
params.pop('silent', None)
params.pop('importance_type', None)
params.pop('n_estimators', None)
params.pop('class_weight', None)
if self._n_classes is not None and self._n_classes > 2:
params['num_class'] = self._n_classes
if hasattr(self, '_eval_at'):
params['eval_at'] = self._eval_at
params['objective'] = self._objective
if self._fobj:
params['objective'] = 'None' # objective = nullptr for unknown objective
if callable(eval_metric):
feval = _eval_function_wrapper(eval_metric)
else:
feval = None
# register default metric for consistency with callable eval_metric case
original_metric = self._objective if isinstance(self._objective, string_type) else None
if original_metric is None:
# try to deduce from class instance
if isinstance(self, LGBMRegressor):
original_metric = "l2"
elif isinstance(self, LGBMClassifier):
original_metric = "multi_logloss" if self._n_classes > 2 else "binary_logloss"
elif isinstance(self, LGBMRanker):
original_metric = "ndcg"
# overwrite default metric by explicitly set metric
for metric_alias in ['metric', 'metrics', 'metric_types']:
if metric_alias in params:
original_metric = params.pop(metric_alias)
# concatenate metric from params (or default if not provided in params) and eval_metric
original_metric = [original_metric] if isinstance(original_metric, (string_type, type(None))) else original_metric
eval_metric = [eval_metric] if isinstance(eval_metric, (string_type, type(None))) else eval_metric
params['metric'] = set(original_metric + eval_metric)
if not isinstance(X, (DataFrame, DataTable)):
_X, _y = _LGBMCheckXY(X, y, accept_sparse=True, force_all_finite=False, ensure_min_samples=2)
_LGBMCheckConsistentLength(_X, _y, sample_weight)
else:
_X, _y = X, y
if self.class_weight is not None:
class_sample_weight = _LGBMComputeSampleWeight(self.class_weight, y)
if sample_weight is None or len(sample_weight) == 0:
sample_weight = class_sample_weight
else:
sample_weight = np.multiply(sample_weight, class_sample_weight)
self._n_features = _X.shape[1]
def _construct_dataset(X, y, sample_weight, init_score, group, params):
ret = Dataset(X, label=y, weight=sample_weight, group=group, params=params)
return ret.set_init_score(init_score)
train_set = _construct_dataset(_X, _y, sample_weight, init_score, group, params)
valid_sets = []
if eval_set is not None:
def _get_meta_data(collection, i):
if collection is None:
return None
elif isinstance(collection, list):
return collection[i] if len(collection) > i else None
elif isinstance(collection, dict):
return collection.get(i, None)
else:
raise TypeError('eval_sample_weight, eval_class_weight, eval_init_score, and eval_group '
'should be dict or list')
if isinstance(eval_set, tuple):
eval_set = [eval_set]
for i, valid_data in enumerate(eval_set):
# reduce cost for prediction training data
if valid_data[0] is X and valid_data[1] is y:
valid_set = train_set
else:
valid_weight = _get_meta_data(eval_sample_weight, i)
if _get_meta_data(eval_class_weight, i) is not None:
valid_class_sample_weight = _LGBMComputeSampleWeight(_get_meta_data(eval_class_weight, i),
valid_data[1])
if valid_weight is None or len(valid_weight) == 0:
valid_weight = valid_class_sample_weight
else:
valid_weight = np.multiply(valid_weight, valid_class_sample_weight)
valid_init_score = _get_meta_data(eval_init_score, i)
valid_group = _get_meta_data(eval_group, i)
valid_set = _construct_dataset(valid_data[0], valid_data[1],
valid_weight, valid_init_score, valid_group, params)
valid_sets.append(valid_set)
self._Booster = train(params, train_set,
self.n_estimators, valid_sets=valid_sets, valid_names=eval_names,
early_stopping_rounds=early_stopping_rounds,
evals_result=evals_result, fobj=self._fobj, feval=feval,
verbose_eval=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
if evals_result:
self._evals_result = evals_result
if early_stopping_rounds is not None:
self._best_iteration = self._Booster.best_iteration
self._best_score = self._Booster.best_score
# free dataset
self.booster_.free_dataset()
del train_set, valid_sets
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"init_score",
"=",
"None",
",",
"group",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_names",
"=",
"None",
",",
"eval_sample_weight",
"=",
"None",
",",
"eval_class_weight",
"=",
"None",
",",
"eval_init_score",
"=",
"None",
",",
"eval_group",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"feature_name",
"=",
"'auto'",
",",
"categorical_feature",
"=",
"'auto'",
",",
"callbacks",
"=",
"None",
")",
":",
"if",
"self",
".",
"_objective",
"is",
"None",
":",
"if",
"isinstance",
"(",
"self",
",",
"LGBMRegressor",
")",
":",
"self",
".",
"_objective",
"=",
"\"regression\"",
"elif",
"isinstance",
"(",
"self",
",",
"LGBMClassifier",
")",
":",
"self",
".",
"_objective",
"=",
"\"binary\"",
"elif",
"isinstance",
"(",
"self",
",",
"LGBMRanker",
")",
":",
"self",
".",
"_objective",
"=",
"\"lambdarank\"",
"else",
":",
"raise",
"ValueError",
"(",
"\"Unknown LGBMModel type.\"",
")",
"if",
"callable",
"(",
"self",
".",
"_objective",
")",
":",
"self",
".",
"_fobj",
"=",
"_objective_function_wrapper",
"(",
"self",
".",
"_objective",
")",
"else",
":",
"self",
".",
"_fobj",
"=",
"None",
"evals_result",
"=",
"{",
"}",
"params",
"=",
"self",
".",
"get_params",
"(",
")",
"# user can set verbose with kwargs, it has higher priority",
"if",
"not",
"any",
"(",
"verbose_alias",
"in",
"params",
"for",
"verbose_alias",
"in",
"(",
"'verbose'",
",",
"'verbosity'",
")",
")",
"and",
"self",
".",
"silent",
":",
"params",
"[",
"'verbose'",
"]",
"=",
"-",
"1",
"params",
".",
"pop",
"(",
"'silent'",
",",
"None",
")",
"params",
".",
"pop",
"(",
"'importance_type'",
",",
"None",
")",
"params",
".",
"pop",
"(",
"'n_estimators'",
",",
"None",
")",
"params",
".",
"pop",
"(",
"'class_weight'",
",",
"None",
")",
"if",
"self",
".",
"_n_classes",
"is",
"not",
"None",
"and",
"self",
".",
"_n_classes",
">",
"2",
":",
"params",
"[",
"'num_class'",
"]",
"=",
"self",
".",
"_n_classes",
"if",
"hasattr",
"(",
"self",
",",
"'_eval_at'",
")",
":",
"params",
"[",
"'eval_at'",
"]",
"=",
"self",
".",
"_eval_at",
"params",
"[",
"'objective'",
"]",
"=",
"self",
".",
"_objective",
"if",
"self",
".",
"_fobj",
":",
"params",
"[",
"'objective'",
"]",
"=",
"'None'",
"# objective = nullptr for unknown objective",
"if",
"callable",
"(",
"eval_metric",
")",
":",
"feval",
"=",
"_eval_function_wrapper",
"(",
"eval_metric",
")",
"else",
":",
"feval",
"=",
"None",
"# register default metric for consistency with callable eval_metric case",
"original_metric",
"=",
"self",
".",
"_objective",
"if",
"isinstance",
"(",
"self",
".",
"_objective",
",",
"string_type",
")",
"else",
"None",
"if",
"original_metric",
"is",
"None",
":",
"# try to deduce from class instance",
"if",
"isinstance",
"(",
"self",
",",
"LGBMRegressor",
")",
":",
"original_metric",
"=",
"\"l2\"",
"elif",
"isinstance",
"(",
"self",
",",
"LGBMClassifier",
")",
":",
"original_metric",
"=",
"\"multi_logloss\"",
"if",
"self",
".",
"_n_classes",
">",
"2",
"else",
"\"binary_logloss\"",
"elif",
"isinstance",
"(",
"self",
",",
"LGBMRanker",
")",
":",
"original_metric",
"=",
"\"ndcg\"",
"# overwrite default metric by explicitly set metric",
"for",
"metric_alias",
"in",
"[",
"'metric'",
",",
"'metrics'",
",",
"'metric_types'",
"]",
":",
"if",
"metric_alias",
"in",
"params",
":",
"original_metric",
"=",
"params",
".",
"pop",
"(",
"metric_alias",
")",
"# concatenate metric from params (or default if not provided in params) and eval_metric",
"original_metric",
"=",
"[",
"original_metric",
"]",
"if",
"isinstance",
"(",
"original_metric",
",",
"(",
"string_type",
",",
"type",
"(",
"None",
")",
")",
")",
"else",
"original_metric",
"eval_metric",
"=",
"[",
"eval_metric",
"]",
"if",
"isinstance",
"(",
"eval_metric",
",",
"(",
"string_type",
",",
"type",
"(",
"None",
")",
")",
")",
"else",
"eval_metric",
"params",
"[",
"'metric'",
"]",
"=",
"set",
"(",
"original_metric",
"+",
"eval_metric",
")",
"if",
"not",
"isinstance",
"(",
"X",
",",
"(",
"DataFrame",
",",
"DataTable",
")",
")",
":",
"_X",
",",
"_y",
"=",
"_LGBMCheckXY",
"(",
"X",
",",
"y",
",",
"accept_sparse",
"=",
"True",
",",
"force_all_finite",
"=",
"False",
",",
"ensure_min_samples",
"=",
"2",
")",
"_LGBMCheckConsistentLength",
"(",
"_X",
",",
"_y",
",",
"sample_weight",
")",
"else",
":",
"_X",
",",
"_y",
"=",
"X",
",",
"y",
"if",
"self",
".",
"class_weight",
"is",
"not",
"None",
":",
"class_sample_weight",
"=",
"_LGBMComputeSampleWeight",
"(",
"self",
".",
"class_weight",
",",
"y",
")",
"if",
"sample_weight",
"is",
"None",
"or",
"len",
"(",
"sample_weight",
")",
"==",
"0",
":",
"sample_weight",
"=",
"class_sample_weight",
"else",
":",
"sample_weight",
"=",
"np",
".",
"multiply",
"(",
"sample_weight",
",",
"class_sample_weight",
")",
"self",
".",
"_n_features",
"=",
"_X",
".",
"shape",
"[",
"1",
"]",
"def",
"_construct_dataset",
"(",
"X",
",",
"y",
",",
"sample_weight",
",",
"init_score",
",",
"group",
",",
"params",
")",
":",
"ret",
"=",
"Dataset",
"(",
"X",
",",
"label",
"=",
"y",
",",
"weight",
"=",
"sample_weight",
",",
"group",
"=",
"group",
",",
"params",
"=",
"params",
")",
"return",
"ret",
".",
"set_init_score",
"(",
"init_score",
")",
"train_set",
"=",
"_construct_dataset",
"(",
"_X",
",",
"_y",
",",
"sample_weight",
",",
"init_score",
",",
"group",
",",
"params",
")",
"valid_sets",
"=",
"[",
"]",
"if",
"eval_set",
"is",
"not",
"None",
":",
"def",
"_get_meta_data",
"(",
"collection",
",",
"i",
")",
":",
"if",
"collection",
"is",
"None",
":",
"return",
"None",
"elif",
"isinstance",
"(",
"collection",
",",
"list",
")",
":",
"return",
"collection",
"[",
"i",
"]",
"if",
"len",
"(",
"collection",
")",
">",
"i",
"else",
"None",
"elif",
"isinstance",
"(",
"collection",
",",
"dict",
")",
":",
"return",
"collection",
".",
"get",
"(",
"i",
",",
"None",
")",
"else",
":",
"raise",
"TypeError",
"(",
"'eval_sample_weight, eval_class_weight, eval_init_score, and eval_group '",
"'should be dict or list'",
")",
"if",
"isinstance",
"(",
"eval_set",
",",
"tuple",
")",
":",
"eval_set",
"=",
"[",
"eval_set",
"]",
"for",
"i",
",",
"valid_data",
"in",
"enumerate",
"(",
"eval_set",
")",
":",
"# reduce cost for prediction training data",
"if",
"valid_data",
"[",
"0",
"]",
"is",
"X",
"and",
"valid_data",
"[",
"1",
"]",
"is",
"y",
":",
"valid_set",
"=",
"train_set",
"else",
":",
"valid_weight",
"=",
"_get_meta_data",
"(",
"eval_sample_weight",
",",
"i",
")",
"if",
"_get_meta_data",
"(",
"eval_class_weight",
",",
"i",
")",
"is",
"not",
"None",
":",
"valid_class_sample_weight",
"=",
"_LGBMComputeSampleWeight",
"(",
"_get_meta_data",
"(",
"eval_class_weight",
",",
"i",
")",
",",
"valid_data",
"[",
"1",
"]",
")",
"if",
"valid_weight",
"is",
"None",
"or",
"len",
"(",
"valid_weight",
")",
"==",
"0",
":",
"valid_weight",
"=",
"valid_class_sample_weight",
"else",
":",
"valid_weight",
"=",
"np",
".",
"multiply",
"(",
"valid_weight",
",",
"valid_class_sample_weight",
")",
"valid_init_score",
"=",
"_get_meta_data",
"(",
"eval_init_score",
",",
"i",
")",
"valid_group",
"=",
"_get_meta_data",
"(",
"eval_group",
",",
"i",
")",
"valid_set",
"=",
"_construct_dataset",
"(",
"valid_data",
"[",
"0",
"]",
",",
"valid_data",
"[",
"1",
"]",
",",
"valid_weight",
",",
"valid_init_score",
",",
"valid_group",
",",
"params",
")",
"valid_sets",
".",
"append",
"(",
"valid_set",
")",
"self",
".",
"_Booster",
"=",
"train",
"(",
"params",
",",
"train_set",
",",
"self",
".",
"n_estimators",
",",
"valid_sets",
"=",
"valid_sets",
",",
"valid_names",
"=",
"eval_names",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"evals_result",
"=",
"evals_result",
",",
"fobj",
"=",
"self",
".",
"_fobj",
",",
"feval",
"=",
"feval",
",",
"verbose_eval",
"=",
"verbose",
",",
"feature_name",
"=",
"feature_name",
",",
"categorical_feature",
"=",
"categorical_feature",
",",
"callbacks",
"=",
"callbacks",
")",
"if",
"evals_result",
":",
"self",
".",
"_evals_result",
"=",
"evals_result",
"if",
"early_stopping_rounds",
"is",
"not",
"None",
":",
"self",
".",
"_best_iteration",
"=",
"self",
".",
"_Booster",
".",
"best_iteration",
"self",
".",
"_best_score",
"=",
"self",
".",
"_Booster",
".",
"best_score",
"# free dataset",
"self",
".",
"booster_",
".",
"free_dataset",
"(",
")",
"del",
"train_set",
",",
"valid_sets",
"return",
"self"
] |
Build a gradient boosting model from the training set (X, y).
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input feature matrix.
y : array-like of shape = [n_samples]
The target values (class labels in classification, real numbers in regression).
sample_weight : array-like of shape = [n_samples] or None, optional (default=None)
Weights of training data.
init_score : array-like of shape = [n_samples] or None, optional (default=None)
Init score of training data.
group : array-like or None, optional (default=None)
Group data of training data.
eval_set : list or None, optional (default=None)
A list of (X, y) tuple pairs to use as validation sets.
eval_names : list of strings or None, optional (default=None)
Names of eval_set.
eval_sample_weight : list of arrays or None, optional (default=None)
Weights of eval data.
eval_class_weight : list or None, optional (default=None)
Class weights of eval data.
eval_init_score : list of arrays or None, optional (default=None)
Init score of eval data.
eval_group : list of arrays or None, optional (default=None)
Group data of eval data.
eval_metric : string, list of strings, callable or None, optional (default=None)
If string, it should be a built-in evaluation metric to use.
If callable, it should be a custom evaluation metric, see note below for more details.
In either case, the ``metric`` from the model parameters will be evaluated and used as well.
Default: 'l2' for LGBMRegressor, 'logloss' for LGBMClassifier, 'ndcg' for LGBMRanker.
early_stopping_rounds : int or None, optional (default=None)
Activates early stopping. The model will train until the validation score stops improving.
Validation score needs to improve at least every ``early_stopping_rounds`` round(s)
to continue training.
Requires at least one validation data and one metric.
If there's more than one, will check all of them. But the training data is ignored anyway.
To check only the first metric you can pass in ``callbacks``
``early_stopping`` callback with ``first_metric_only=True``.
verbose : bool or int, optional (default=True)
Requires at least one evaluation data.
If True, the eval metric on the eval set is printed at each boosting stage.
If int, the eval metric on the eval set is printed at every ``verbose`` boosting stage.
The last boosting stage or the boosting stage found by using ``early_stopping_rounds`` is also printed.
Example
-------
With ``verbose`` = 4 and at least one item in ``eval_set``,
an evaluation metric is printed every 4 (instead of 1) boosting stages.
feature_name : list of strings or 'auto', optional (default='auto')
Feature names.
If 'auto' and data is pandas DataFrame, data columns names are used.
categorical_feature : list of strings or int, or 'auto', optional (default='auto')
Categorical features.
If list of int, interpreted as indices.
If list of strings, interpreted as feature names (need to specify ``feature_name`` as well).
If 'auto' and data is pandas DataFrame, pandas unordered categorical columns are used.
All values in categorical features should be less than int32 max value (2147483647).
Large values could be memory consuming. Consider using consecutive integers starting from zero.
All negative values in categorical features will be treated as missing values.
callbacks : list of callback functions or None, optional (default=None)
List of callback functions that are applied at each iteration.
See Callbacks in Python API for more information.
Returns
-------
self : object
Returns self.
Note
----
Custom eval function expects a callable with following signatures:
``func(y_true, y_pred)``, ``func(y_true, y_pred, weight)`` or
``func(y_true, y_pred, weight, group)``
and returns (eval_name, eval_result, is_bigger_better) or
list of (eval_name, eval_result, is_bigger_better):
y_true : array-like of shape = [n_samples]
The target values.
y_pred : array-like of shape = [n_samples] or shape = [n_samples * n_classes] (for multi-class task)
The predicted values.
weight : array-like of shape = [n_samples]
The weight of samples.
group : array-like
Group/query data, used for ranking task.
eval_name : string
The name of evaluation.
eval_result : float
The eval result.
is_bigger_better : bool
Is eval result bigger better, e.g. AUC is bigger_better.
For multi-class task, the y_pred is group by class_id first, then group by row_id.
If you want to get i-th row y_pred in j-th class, the access way is y_pred[j * num_data + i].
|
[
"Build",
"a",
"gradient",
"boosting",
"model",
"from",
"the",
"training",
"set",
"(",
"X",
"y",
")",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L332-L562
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMModel.predict
|
def predict(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Return the predicted value for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
The predicted values.
X_leaves : array-like of shape = [n_samples, n_trees] or shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
"""
if self._n_features is None:
raise LGBMNotFittedError("Estimator not fitted, call `fit` before exploiting the model.")
if not isinstance(X, (DataFrame, DataTable)):
X = _LGBMCheckArray(X, accept_sparse=True, force_all_finite=False)
n_features = X.shape[1]
if self._n_features != n_features:
raise ValueError("Number of features of the model must "
"match the input. Model n_features_ is %s and "
"input n_features is %s "
% (self._n_features, n_features))
return self.booster_.predict(X, raw_score=raw_score, num_iteration=num_iteration,
pred_leaf=pred_leaf, pred_contrib=pred_contrib, **kwargs)
|
python
|
def predict(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Return the predicted value for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
The predicted values.
X_leaves : array-like of shape = [n_samples, n_trees] or shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
"""
if self._n_features is None:
raise LGBMNotFittedError("Estimator not fitted, call `fit` before exploiting the model.")
if not isinstance(X, (DataFrame, DataTable)):
X = _LGBMCheckArray(X, accept_sparse=True, force_all_finite=False)
n_features = X.shape[1]
if self._n_features != n_features:
raise ValueError("Number of features of the model must "
"match the input. Model n_features_ is %s and "
"input n_features is %s "
% (self._n_features, n_features))
return self.booster_.predict(X, raw_score=raw_score, num_iteration=num_iteration,
pred_leaf=pred_leaf, pred_contrib=pred_contrib, **kwargs)
|
[
"def",
"predict",
"(",
"self",
",",
"X",
",",
"raw_score",
"=",
"False",
",",
"num_iteration",
"=",
"None",
",",
"pred_leaf",
"=",
"False",
",",
"pred_contrib",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"self",
".",
"_n_features",
"is",
"None",
":",
"raise",
"LGBMNotFittedError",
"(",
"\"Estimator not fitted, call `fit` before exploiting the model.\"",
")",
"if",
"not",
"isinstance",
"(",
"X",
",",
"(",
"DataFrame",
",",
"DataTable",
")",
")",
":",
"X",
"=",
"_LGBMCheckArray",
"(",
"X",
",",
"accept_sparse",
"=",
"True",
",",
"force_all_finite",
"=",
"False",
")",
"n_features",
"=",
"X",
".",
"shape",
"[",
"1",
"]",
"if",
"self",
".",
"_n_features",
"!=",
"n_features",
":",
"raise",
"ValueError",
"(",
"\"Number of features of the model must \"",
"\"match the input. Model n_features_ is %s and \"",
"\"input n_features is %s \"",
"%",
"(",
"self",
".",
"_n_features",
",",
"n_features",
")",
")",
"return",
"self",
".",
"booster_",
".",
"predict",
"(",
"X",
",",
"raw_score",
"=",
"raw_score",
",",
"num_iteration",
"=",
"num_iteration",
",",
"pred_leaf",
"=",
"pred_leaf",
",",
"pred_contrib",
"=",
"pred_contrib",
",",
"*",
"*",
"kwargs",
")"
] |
Return the predicted value for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_result : array-like of shape = [n_samples] or shape = [n_samples, n_classes]
The predicted values.
X_leaves : array-like of shape = [n_samples, n_trees] or shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, n_features + 1] or shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
|
[
"Return",
"the",
"predicted",
"value",
"for",
"each",
"sample",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L564-L614
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMModel.feature_importances_
|
def feature_importances_(self):
"""Get feature importances.
Note
----
Feature importance in sklearn interface used to normalize to 1,
it's deprecated after 2.0.4 and is the same as Booster.feature_importance() now.
``importance_type`` attribute is passed to the function
to configure the type of importance values to be extracted.
"""
if self._n_features is None:
raise LGBMNotFittedError('No feature_importances found. Need to call fit beforehand.')
return self.booster_.feature_importance(importance_type=self.importance_type)
|
python
|
def feature_importances_(self):
"""Get feature importances.
Note
----
Feature importance in sklearn interface used to normalize to 1,
it's deprecated after 2.0.4 and is the same as Booster.feature_importance() now.
``importance_type`` attribute is passed to the function
to configure the type of importance values to be extracted.
"""
if self._n_features is None:
raise LGBMNotFittedError('No feature_importances found. Need to call fit beforehand.')
return self.booster_.feature_importance(importance_type=self.importance_type)
|
[
"def",
"feature_importances_",
"(",
"self",
")",
":",
"if",
"self",
".",
"_n_features",
"is",
"None",
":",
"raise",
"LGBMNotFittedError",
"(",
"'No feature_importances found. Need to call fit beforehand.'",
")",
"return",
"self",
".",
"booster_",
".",
"feature_importance",
"(",
"importance_type",
"=",
"self",
".",
"importance_type",
")"
] |
Get feature importances.
Note
----
Feature importance in sklearn interface used to normalize to 1,
it's deprecated after 2.0.4 and is the same as Booster.feature_importance() now.
``importance_type`` attribute is passed to the function
to configure the type of importance values to be extracted.
|
[
"Get",
"feature",
"importances",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L659-L671
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMRegressor.fit
|
def fit(self, X, y,
sample_weight=None, init_score=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_init_score=None, eval_metric=None, early_stopping_rounds=None,
verbose=True, feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
super(LGBMRegressor, self).fit(X, y, sample_weight=sample_weight,
init_score=init_score, eval_set=eval_set,
eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_init_score=eval_init_score,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
python
|
def fit(self, X, y,
sample_weight=None, init_score=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_init_score=None, eval_metric=None, early_stopping_rounds=None,
verbose=True, feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
super(LGBMRegressor, self).fit(X, y, sample_weight=sample_weight,
init_score=init_score, eval_set=eval_set,
eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_init_score=eval_init_score,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"init_score",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_names",
"=",
"None",
",",
"eval_sample_weight",
"=",
"None",
",",
"eval_init_score",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"feature_name",
"=",
"'auto'",
",",
"categorical_feature",
"=",
"'auto'",
",",
"callbacks",
"=",
"None",
")",
":",
"super",
"(",
"LGBMRegressor",
",",
"self",
")",
".",
"fit",
"(",
"X",
",",
"y",
",",
"sample_weight",
"=",
"sample_weight",
",",
"init_score",
"=",
"init_score",
",",
"eval_set",
"=",
"eval_set",
",",
"eval_names",
"=",
"eval_names",
",",
"eval_sample_weight",
"=",
"eval_sample_weight",
",",
"eval_init_score",
"=",
"eval_init_score",
",",
"eval_metric",
"=",
"eval_metric",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"verbose",
"=",
"verbose",
",",
"feature_name",
"=",
"feature_name",
",",
"categorical_feature",
"=",
"categorical_feature",
",",
"callbacks",
"=",
"callbacks",
")",
"return",
"self"
] |
Docstring is inherited from the LGBMModel.
|
[
"Docstring",
"is",
"inherited",
"from",
"the",
"LGBMModel",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L677-L693
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMClassifier.fit
|
def fit(self, X, y,
sample_weight=None, init_score=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_class_weight=None, eval_init_score=None, eval_metric=None,
early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
_LGBMAssertAllFinite(y)
_LGBMCheckClassificationTargets(y)
self._le = _LGBMLabelEncoder().fit(y)
_y = self._le.transform(y)
self._classes = self._le.classes_
self._n_classes = len(self._classes)
if self._n_classes > 2:
# Switch to using a multiclass objective in the underlying LGBM instance
ova_aliases = ("multiclassova", "multiclass_ova", "ova", "ovr")
if self._objective not in ova_aliases and not callable(self._objective):
self._objective = "multiclass"
if eval_metric in ('logloss', 'binary_logloss'):
eval_metric = "multi_logloss"
elif eval_metric in ('error', 'binary_error'):
eval_metric = "multi_error"
else:
if eval_metric in ('logloss', 'multi_logloss'):
eval_metric = 'binary_logloss'
elif eval_metric in ('error', 'multi_error'):
eval_metric = 'binary_error'
if eval_set is not None:
if isinstance(eval_set, tuple):
eval_set = [eval_set]
for i, (valid_x, valid_y) in enumerate(eval_set):
if valid_x is X and valid_y is y:
eval_set[i] = (valid_x, _y)
else:
eval_set[i] = (valid_x, self._le.transform(valid_y))
super(LGBMClassifier, self).fit(X, _y, sample_weight=sample_weight,
init_score=init_score, eval_set=eval_set,
eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_class_weight=eval_class_weight,
eval_init_score=eval_init_score,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
python
|
def fit(self, X, y,
sample_weight=None, init_score=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_class_weight=None, eval_init_score=None, eval_metric=None,
early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
_LGBMAssertAllFinite(y)
_LGBMCheckClassificationTargets(y)
self._le = _LGBMLabelEncoder().fit(y)
_y = self._le.transform(y)
self._classes = self._le.classes_
self._n_classes = len(self._classes)
if self._n_classes > 2:
# Switch to using a multiclass objective in the underlying LGBM instance
ova_aliases = ("multiclassova", "multiclass_ova", "ova", "ovr")
if self._objective not in ova_aliases and not callable(self._objective):
self._objective = "multiclass"
if eval_metric in ('logloss', 'binary_logloss'):
eval_metric = "multi_logloss"
elif eval_metric in ('error', 'binary_error'):
eval_metric = "multi_error"
else:
if eval_metric in ('logloss', 'multi_logloss'):
eval_metric = 'binary_logloss'
elif eval_metric in ('error', 'multi_error'):
eval_metric = 'binary_error'
if eval_set is not None:
if isinstance(eval_set, tuple):
eval_set = [eval_set]
for i, (valid_x, valid_y) in enumerate(eval_set):
if valid_x is X and valid_y is y:
eval_set[i] = (valid_x, _y)
else:
eval_set[i] = (valid_x, self._le.transform(valid_y))
super(LGBMClassifier, self).fit(X, _y, sample_weight=sample_weight,
init_score=init_score, eval_set=eval_set,
eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_class_weight=eval_class_weight,
eval_init_score=eval_init_score,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"init_score",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_names",
"=",
"None",
",",
"eval_sample_weight",
"=",
"None",
",",
"eval_class_weight",
"=",
"None",
",",
"eval_init_score",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"feature_name",
"=",
"'auto'",
",",
"categorical_feature",
"=",
"'auto'",
",",
"callbacks",
"=",
"None",
")",
":",
"_LGBMAssertAllFinite",
"(",
"y",
")",
"_LGBMCheckClassificationTargets",
"(",
"y",
")",
"self",
".",
"_le",
"=",
"_LGBMLabelEncoder",
"(",
")",
".",
"fit",
"(",
"y",
")",
"_y",
"=",
"self",
".",
"_le",
".",
"transform",
"(",
"y",
")",
"self",
".",
"_classes",
"=",
"self",
".",
"_le",
".",
"classes_",
"self",
".",
"_n_classes",
"=",
"len",
"(",
"self",
".",
"_classes",
")",
"if",
"self",
".",
"_n_classes",
">",
"2",
":",
"# Switch to using a multiclass objective in the underlying LGBM instance",
"ova_aliases",
"=",
"(",
"\"multiclassova\"",
",",
"\"multiclass_ova\"",
",",
"\"ova\"",
",",
"\"ovr\"",
")",
"if",
"self",
".",
"_objective",
"not",
"in",
"ova_aliases",
"and",
"not",
"callable",
"(",
"self",
".",
"_objective",
")",
":",
"self",
".",
"_objective",
"=",
"\"multiclass\"",
"if",
"eval_metric",
"in",
"(",
"'logloss'",
",",
"'binary_logloss'",
")",
":",
"eval_metric",
"=",
"\"multi_logloss\"",
"elif",
"eval_metric",
"in",
"(",
"'error'",
",",
"'binary_error'",
")",
":",
"eval_metric",
"=",
"\"multi_error\"",
"else",
":",
"if",
"eval_metric",
"in",
"(",
"'logloss'",
",",
"'multi_logloss'",
")",
":",
"eval_metric",
"=",
"'binary_logloss'",
"elif",
"eval_metric",
"in",
"(",
"'error'",
",",
"'multi_error'",
")",
":",
"eval_metric",
"=",
"'binary_error'",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"isinstance",
"(",
"eval_set",
",",
"tuple",
")",
":",
"eval_set",
"=",
"[",
"eval_set",
"]",
"for",
"i",
",",
"(",
"valid_x",
",",
"valid_y",
")",
"in",
"enumerate",
"(",
"eval_set",
")",
":",
"if",
"valid_x",
"is",
"X",
"and",
"valid_y",
"is",
"y",
":",
"eval_set",
"[",
"i",
"]",
"=",
"(",
"valid_x",
",",
"_y",
")",
"else",
":",
"eval_set",
"[",
"i",
"]",
"=",
"(",
"valid_x",
",",
"self",
".",
"_le",
".",
"transform",
"(",
"valid_y",
")",
")",
"super",
"(",
"LGBMClassifier",
",",
"self",
")",
".",
"fit",
"(",
"X",
",",
"_y",
",",
"sample_weight",
"=",
"sample_weight",
",",
"init_score",
"=",
"init_score",
",",
"eval_set",
"=",
"eval_set",
",",
"eval_names",
"=",
"eval_names",
",",
"eval_sample_weight",
"=",
"eval_sample_weight",
",",
"eval_class_weight",
"=",
"eval_class_weight",
",",
"eval_init_score",
"=",
"eval_init_score",
",",
"eval_metric",
"=",
"eval_metric",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"verbose",
"=",
"verbose",
",",
"feature_name",
"=",
"feature_name",
",",
"categorical_feature",
"=",
"categorical_feature",
",",
"callbacks",
"=",
"callbacks",
")",
"return",
"self"
] |
Docstring is inherited from the LGBMModel.
|
[
"Docstring",
"is",
"inherited",
"from",
"the",
"LGBMModel",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L703-L752
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMClassifier.predict
|
def predict(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Docstring is inherited from the LGBMModel."""
result = self.predict_proba(X, raw_score, num_iteration,
pred_leaf, pred_contrib, **kwargs)
if raw_score or pred_leaf or pred_contrib:
return result
else:
class_index = np.argmax(result, axis=1)
return self._le.inverse_transform(class_index)
|
python
|
def predict(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Docstring is inherited from the LGBMModel."""
result = self.predict_proba(X, raw_score, num_iteration,
pred_leaf, pred_contrib, **kwargs)
if raw_score or pred_leaf or pred_contrib:
return result
else:
class_index = np.argmax(result, axis=1)
return self._le.inverse_transform(class_index)
|
[
"def",
"predict",
"(",
"self",
",",
"X",
",",
"raw_score",
"=",
"False",
",",
"num_iteration",
"=",
"None",
",",
"pred_leaf",
"=",
"False",
",",
"pred_contrib",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"result",
"=",
"self",
".",
"predict_proba",
"(",
"X",
",",
"raw_score",
",",
"num_iteration",
",",
"pred_leaf",
",",
"pred_contrib",
",",
"*",
"*",
"kwargs",
")",
"if",
"raw_score",
"or",
"pred_leaf",
"or",
"pred_contrib",
":",
"return",
"result",
"else",
":",
"class_index",
"=",
"np",
".",
"argmax",
"(",
"result",
",",
"axis",
"=",
"1",
")",
"return",
"self",
".",
"_le",
".",
"inverse_transform",
"(",
"class_index",
")"
] |
Docstring is inherited from the LGBMModel.
|
[
"Docstring",
"is",
"inherited",
"from",
"the",
"LGBMModel",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L756-L765
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMClassifier.predict_proba
|
def predict_proba(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Return the predicted probability for each class for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_probability : array-like of shape = [n_samples, n_classes]
The predicted probability for each class for each sample.
X_leaves : array-like of shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
"""
result = super(LGBMClassifier, self).predict(X, raw_score, num_iteration,
pred_leaf, pred_contrib, **kwargs)
if self._n_classes > 2 or raw_score or pred_leaf or pred_contrib:
return result
else:
return np.vstack((1. - result, result)).transpose()
|
python
|
def predict_proba(self, X, raw_score=False, num_iteration=None,
pred_leaf=False, pred_contrib=False, **kwargs):
"""Return the predicted probability for each class for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_probability : array-like of shape = [n_samples, n_classes]
The predicted probability for each class for each sample.
X_leaves : array-like of shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
"""
result = super(LGBMClassifier, self).predict(X, raw_score, num_iteration,
pred_leaf, pred_contrib, **kwargs)
if self._n_classes > 2 or raw_score or pred_leaf or pred_contrib:
return result
else:
return np.vstack((1. - result, result)).transpose()
|
[
"def",
"predict_proba",
"(",
"self",
",",
"X",
",",
"raw_score",
"=",
"False",
",",
"num_iteration",
"=",
"None",
",",
"pred_leaf",
"=",
"False",
",",
"pred_contrib",
"=",
"False",
",",
"*",
"*",
"kwargs",
")",
":",
"result",
"=",
"super",
"(",
"LGBMClassifier",
",",
"self",
")",
".",
"predict",
"(",
"X",
",",
"raw_score",
",",
"num_iteration",
",",
"pred_leaf",
",",
"pred_contrib",
",",
"*",
"*",
"kwargs",
")",
"if",
"self",
".",
"_n_classes",
">",
"2",
"or",
"raw_score",
"or",
"pred_leaf",
"or",
"pred_contrib",
":",
"return",
"result",
"else",
":",
"return",
"np",
".",
"vstack",
"(",
"(",
"1.",
"-",
"result",
",",
"result",
")",
")",
".",
"transpose",
"(",
")"
] |
Return the predicted probability for each class for each sample.
Parameters
----------
X : array-like or sparse matrix of shape = [n_samples, n_features]
Input features matrix.
raw_score : bool, optional (default=False)
Whether to predict raw scores.
num_iteration : int or None, optional (default=None)
Limit number of iterations in the prediction.
If None, if the best iteration exists, it is used; otherwise, all trees are used.
If <= 0, all trees are used (no limits).
pred_leaf : bool, optional (default=False)
Whether to predict leaf index.
pred_contrib : bool, optional (default=False)
Whether to predict feature contributions.
Note
----
If you want to get more explanations for your model's predictions using SHAP values,
like SHAP interaction values,
you can install the shap package (https://github.com/slundberg/shap).
Note that unlike the shap package, with ``pred_contrib`` we return a matrix with an extra
column, where the last column is the expected value.
**kwargs
Other parameters for the prediction.
Returns
-------
predicted_probability : array-like of shape = [n_samples, n_classes]
The predicted probability for each class for each sample.
X_leaves : array-like of shape = [n_samples, n_trees * n_classes]
If ``pred_leaf=True``, the predicted leaf of every tree for each sample.
X_SHAP_values : array-like of shape = [n_samples, (n_features + 1) * n_classes]
If ``pred_contrib=True``, the feature contributions for each sample.
|
[
"Return",
"the",
"predicted",
"probability",
"for",
"each",
"class",
"for",
"each",
"sample",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L769-L813
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/sklearn.py
|
LGBMRanker.fit
|
def fit(self, X, y,
sample_weight=None, init_score=None, group=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_init_score=None, eval_group=None, eval_metric=None,
eval_at=[1], early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
# check group data
if group is None:
raise ValueError("Should set group for ranking task")
if eval_set is not None:
if eval_group is None:
raise ValueError("Eval_group cannot be None when eval_set is not None")
elif len(eval_group) != len(eval_set):
raise ValueError("Length of eval_group should be equal to eval_set")
elif (isinstance(eval_group, dict)
and any(i not in eval_group or eval_group[i] is None for i in range_(len(eval_group)))
or isinstance(eval_group, list)
and any(group is None for group in eval_group)):
raise ValueError("Should set group for all eval datasets for ranking task; "
"if you use dict, the index should start from 0")
self._eval_at = eval_at
super(LGBMRanker, self).fit(X, y, sample_weight=sample_weight,
init_score=init_score, group=group,
eval_set=eval_set, eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_init_score=eval_init_score, eval_group=eval_group,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
python
|
def fit(self, X, y,
sample_weight=None, init_score=None, group=None,
eval_set=None, eval_names=None, eval_sample_weight=None,
eval_init_score=None, eval_group=None, eval_metric=None,
eval_at=[1], early_stopping_rounds=None, verbose=True,
feature_name='auto', categorical_feature='auto', callbacks=None):
"""Docstring is inherited from the LGBMModel."""
# check group data
if group is None:
raise ValueError("Should set group for ranking task")
if eval_set is not None:
if eval_group is None:
raise ValueError("Eval_group cannot be None when eval_set is not None")
elif len(eval_group) != len(eval_set):
raise ValueError("Length of eval_group should be equal to eval_set")
elif (isinstance(eval_group, dict)
and any(i not in eval_group or eval_group[i] is None for i in range_(len(eval_group)))
or isinstance(eval_group, list)
and any(group is None for group in eval_group)):
raise ValueError("Should set group for all eval datasets for ranking task; "
"if you use dict, the index should start from 0")
self._eval_at = eval_at
super(LGBMRanker, self).fit(X, y, sample_weight=sample_weight,
init_score=init_score, group=group,
eval_set=eval_set, eval_names=eval_names,
eval_sample_weight=eval_sample_weight,
eval_init_score=eval_init_score, eval_group=eval_group,
eval_metric=eval_metric,
early_stopping_rounds=early_stopping_rounds,
verbose=verbose, feature_name=feature_name,
categorical_feature=categorical_feature,
callbacks=callbacks)
return self
|
[
"def",
"fit",
"(",
"self",
",",
"X",
",",
"y",
",",
"sample_weight",
"=",
"None",
",",
"init_score",
"=",
"None",
",",
"group",
"=",
"None",
",",
"eval_set",
"=",
"None",
",",
"eval_names",
"=",
"None",
",",
"eval_sample_weight",
"=",
"None",
",",
"eval_init_score",
"=",
"None",
",",
"eval_group",
"=",
"None",
",",
"eval_metric",
"=",
"None",
",",
"eval_at",
"=",
"[",
"1",
"]",
",",
"early_stopping_rounds",
"=",
"None",
",",
"verbose",
"=",
"True",
",",
"feature_name",
"=",
"'auto'",
",",
"categorical_feature",
"=",
"'auto'",
",",
"callbacks",
"=",
"None",
")",
":",
"# check group data",
"if",
"group",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"Should set group for ranking task\"",
")",
"if",
"eval_set",
"is",
"not",
"None",
":",
"if",
"eval_group",
"is",
"None",
":",
"raise",
"ValueError",
"(",
"\"Eval_group cannot be None when eval_set is not None\"",
")",
"elif",
"len",
"(",
"eval_group",
")",
"!=",
"len",
"(",
"eval_set",
")",
":",
"raise",
"ValueError",
"(",
"\"Length of eval_group should be equal to eval_set\"",
")",
"elif",
"(",
"isinstance",
"(",
"eval_group",
",",
"dict",
")",
"and",
"any",
"(",
"i",
"not",
"in",
"eval_group",
"or",
"eval_group",
"[",
"i",
"]",
"is",
"None",
"for",
"i",
"in",
"range_",
"(",
"len",
"(",
"eval_group",
")",
")",
")",
"or",
"isinstance",
"(",
"eval_group",
",",
"list",
")",
"and",
"any",
"(",
"group",
"is",
"None",
"for",
"group",
"in",
"eval_group",
")",
")",
":",
"raise",
"ValueError",
"(",
"\"Should set group for all eval datasets for ranking task; \"",
"\"if you use dict, the index should start from 0\"",
")",
"self",
".",
"_eval_at",
"=",
"eval_at",
"super",
"(",
"LGBMRanker",
",",
"self",
")",
".",
"fit",
"(",
"X",
",",
"y",
",",
"sample_weight",
"=",
"sample_weight",
",",
"init_score",
"=",
"init_score",
",",
"group",
"=",
"group",
",",
"eval_set",
"=",
"eval_set",
",",
"eval_names",
"=",
"eval_names",
",",
"eval_sample_weight",
"=",
"eval_sample_weight",
",",
"eval_init_score",
"=",
"eval_init_score",
",",
"eval_group",
"=",
"eval_group",
",",
"eval_metric",
"=",
"eval_metric",
",",
"early_stopping_rounds",
"=",
"early_stopping_rounds",
",",
"verbose",
"=",
"verbose",
",",
"feature_name",
"=",
"feature_name",
",",
"categorical_feature",
"=",
"categorical_feature",
",",
"callbacks",
"=",
"callbacks",
")",
"return",
"self"
] |
Docstring is inherited from the LGBMModel.
|
[
"Docstring",
"is",
"inherited",
"from",
"the",
"LGBMModel",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/sklearn.py#L833-L867
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
get_parameter_infos
|
def get_parameter_infos(config_hpp):
"""Parse config header file.
Parameters
----------
config_hpp : string
Path to the config header file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
"""
is_inparameter = False
parameter_group = None
cur_key = None
cur_info = {}
keys = []
member_infos = []
with open(config_hpp) as config_hpp_file:
for line in config_hpp_file:
if "#pragma region Parameters" in line:
is_inparameter = True
elif "#pragma region" in line and "Parameters" in line:
cur_key = line.split("region")[1].strip()
keys.append(cur_key)
member_infos.append([])
elif '#pragma endregion' in line:
if cur_key is not None:
cur_key = None
elif is_inparameter:
is_inparameter = False
elif cur_key is not None:
line = line.strip()
if line.startswith("//"):
key, _, val = line[2:].partition("=")
key = key.strip()
val = val.strip()
if key not in cur_info:
if key == "descl2" and "desc" not in cur_info:
cur_info["desc"] = []
elif key != "descl2":
cur_info[key] = []
if key == "desc":
cur_info["desc"].append(("l1", val))
elif key == "descl2":
cur_info["desc"].append(("l2", val))
else:
cur_info[key].append(val)
elif line:
has_eqsgn = False
tokens = line.split("=")
if len(tokens) == 2:
if "default" not in cur_info:
cur_info["default"] = [tokens[1][:-1].strip()]
has_eqsgn = True
tokens = line.split()
cur_info["inner_type"] = [tokens[0].strip()]
if "name" not in cur_info:
if has_eqsgn:
cur_info["name"] = [tokens[1].strip()]
else:
cur_info["name"] = [tokens[1][:-1].strip()]
member_infos[-1].append(cur_info)
cur_info = {}
return keys, member_infos
|
python
|
def get_parameter_infos(config_hpp):
"""Parse config header file.
Parameters
----------
config_hpp : string
Path to the config header file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
"""
is_inparameter = False
parameter_group = None
cur_key = None
cur_info = {}
keys = []
member_infos = []
with open(config_hpp) as config_hpp_file:
for line in config_hpp_file:
if "#pragma region Parameters" in line:
is_inparameter = True
elif "#pragma region" in line and "Parameters" in line:
cur_key = line.split("region")[1].strip()
keys.append(cur_key)
member_infos.append([])
elif '#pragma endregion' in line:
if cur_key is not None:
cur_key = None
elif is_inparameter:
is_inparameter = False
elif cur_key is not None:
line = line.strip()
if line.startswith("//"):
key, _, val = line[2:].partition("=")
key = key.strip()
val = val.strip()
if key not in cur_info:
if key == "descl2" and "desc" not in cur_info:
cur_info["desc"] = []
elif key != "descl2":
cur_info[key] = []
if key == "desc":
cur_info["desc"].append(("l1", val))
elif key == "descl2":
cur_info["desc"].append(("l2", val))
else:
cur_info[key].append(val)
elif line:
has_eqsgn = False
tokens = line.split("=")
if len(tokens) == 2:
if "default" not in cur_info:
cur_info["default"] = [tokens[1][:-1].strip()]
has_eqsgn = True
tokens = line.split()
cur_info["inner_type"] = [tokens[0].strip()]
if "name" not in cur_info:
if has_eqsgn:
cur_info["name"] = [tokens[1].strip()]
else:
cur_info["name"] = [tokens[1][:-1].strip()]
member_infos[-1].append(cur_info)
cur_info = {}
return keys, member_infos
|
[
"def",
"get_parameter_infos",
"(",
"config_hpp",
")",
":",
"is_inparameter",
"=",
"False",
"parameter_group",
"=",
"None",
"cur_key",
"=",
"None",
"cur_info",
"=",
"{",
"}",
"keys",
"=",
"[",
"]",
"member_infos",
"=",
"[",
"]",
"with",
"open",
"(",
"config_hpp",
")",
"as",
"config_hpp_file",
":",
"for",
"line",
"in",
"config_hpp_file",
":",
"if",
"\"#pragma region Parameters\"",
"in",
"line",
":",
"is_inparameter",
"=",
"True",
"elif",
"\"#pragma region\"",
"in",
"line",
"and",
"\"Parameters\"",
"in",
"line",
":",
"cur_key",
"=",
"line",
".",
"split",
"(",
"\"region\"",
")",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"keys",
".",
"append",
"(",
"cur_key",
")",
"member_infos",
".",
"append",
"(",
"[",
"]",
")",
"elif",
"'#pragma endregion'",
"in",
"line",
":",
"if",
"cur_key",
"is",
"not",
"None",
":",
"cur_key",
"=",
"None",
"elif",
"is_inparameter",
":",
"is_inparameter",
"=",
"False",
"elif",
"cur_key",
"is",
"not",
"None",
":",
"line",
"=",
"line",
".",
"strip",
"(",
")",
"if",
"line",
".",
"startswith",
"(",
"\"//\"",
")",
":",
"key",
",",
"_",
",",
"val",
"=",
"line",
"[",
"2",
":",
"]",
".",
"partition",
"(",
"\"=\"",
")",
"key",
"=",
"key",
".",
"strip",
"(",
")",
"val",
"=",
"val",
".",
"strip",
"(",
")",
"if",
"key",
"not",
"in",
"cur_info",
":",
"if",
"key",
"==",
"\"descl2\"",
"and",
"\"desc\"",
"not",
"in",
"cur_info",
":",
"cur_info",
"[",
"\"desc\"",
"]",
"=",
"[",
"]",
"elif",
"key",
"!=",
"\"descl2\"",
":",
"cur_info",
"[",
"key",
"]",
"=",
"[",
"]",
"if",
"key",
"==",
"\"desc\"",
":",
"cur_info",
"[",
"\"desc\"",
"]",
".",
"append",
"(",
"(",
"\"l1\"",
",",
"val",
")",
")",
"elif",
"key",
"==",
"\"descl2\"",
":",
"cur_info",
"[",
"\"desc\"",
"]",
".",
"append",
"(",
"(",
"\"l2\"",
",",
"val",
")",
")",
"else",
":",
"cur_info",
"[",
"key",
"]",
".",
"append",
"(",
"val",
")",
"elif",
"line",
":",
"has_eqsgn",
"=",
"False",
"tokens",
"=",
"line",
".",
"split",
"(",
"\"=\"",
")",
"if",
"len",
"(",
"tokens",
")",
"==",
"2",
":",
"if",
"\"default\"",
"not",
"in",
"cur_info",
":",
"cur_info",
"[",
"\"default\"",
"]",
"=",
"[",
"tokens",
"[",
"1",
"]",
"[",
":",
"-",
"1",
"]",
".",
"strip",
"(",
")",
"]",
"has_eqsgn",
"=",
"True",
"tokens",
"=",
"line",
".",
"split",
"(",
")",
"cur_info",
"[",
"\"inner_type\"",
"]",
"=",
"[",
"tokens",
"[",
"0",
"]",
".",
"strip",
"(",
")",
"]",
"if",
"\"name\"",
"not",
"in",
"cur_info",
":",
"if",
"has_eqsgn",
":",
"cur_info",
"[",
"\"name\"",
"]",
"=",
"[",
"tokens",
"[",
"1",
"]",
".",
"strip",
"(",
")",
"]",
"else",
":",
"cur_info",
"[",
"\"name\"",
"]",
"=",
"[",
"tokens",
"[",
"1",
"]",
"[",
":",
"-",
"1",
"]",
".",
"strip",
"(",
")",
"]",
"member_infos",
"[",
"-",
"1",
"]",
".",
"append",
"(",
"cur_info",
")",
"cur_info",
"=",
"{",
"}",
"return",
"keys",
",",
"member_infos"
] |
Parse config header file.
Parameters
----------
config_hpp : string
Path to the config header file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
|
[
"Parse",
"config",
"header",
"file",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L12-L77
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
get_names
|
def get_names(infos):
"""Get names of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
names : list
Names of all parameters.
"""
names = []
for x in infos:
for y in x:
names.append(y["name"][0])
return names
|
python
|
def get_names(infos):
"""Get names of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
names : list
Names of all parameters.
"""
names = []
for x in infos:
for y in x:
names.append(y["name"][0])
return names
|
[
"def",
"get_names",
"(",
"infos",
")",
":",
"names",
"=",
"[",
"]",
"for",
"x",
"in",
"infos",
":",
"for",
"y",
"in",
"x",
":",
"names",
".",
"append",
"(",
"y",
"[",
"\"name\"",
"]",
"[",
"0",
"]",
")",
"return",
"names"
] |
Get names of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
names : list
Names of all parameters.
|
[
"Get",
"names",
"of",
"all",
"parameters",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L80-L97
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
get_alias
|
def get_alias(infos):
"""Get aliases of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
pairs : list
List of tuples (param alias, param name).
"""
pairs = []
for x in infos:
for y in x:
if "alias" in y:
name = y["name"][0]
alias = y["alias"][0].split(',')
for name2 in alias:
pairs.append((name2.strip(), name))
return pairs
|
python
|
def get_alias(infos):
"""Get aliases of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
pairs : list
List of tuples (param alias, param name).
"""
pairs = []
for x in infos:
for y in x:
if "alias" in y:
name = y["name"][0]
alias = y["alias"][0].split(',')
for name2 in alias:
pairs.append((name2.strip(), name))
return pairs
|
[
"def",
"get_alias",
"(",
"infos",
")",
":",
"pairs",
"=",
"[",
"]",
"for",
"x",
"in",
"infos",
":",
"for",
"y",
"in",
"x",
":",
"if",
"\"alias\"",
"in",
"y",
":",
"name",
"=",
"y",
"[",
"\"name\"",
"]",
"[",
"0",
"]",
"alias",
"=",
"y",
"[",
"\"alias\"",
"]",
"[",
"0",
"]",
".",
"split",
"(",
"','",
")",
"for",
"name2",
"in",
"alias",
":",
"pairs",
".",
"append",
"(",
"(",
"name2",
".",
"strip",
"(",
")",
",",
"name",
")",
")",
"return",
"pairs"
] |
Get aliases of all parameters.
Parameters
----------
infos : list
Content of the config header file.
Returns
-------
pairs : list
List of tuples (param alias, param name).
|
[
"Get",
"aliases",
"of",
"all",
"parameters",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L100-L121
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
set_one_var_from_string
|
def set_one_var_from_string(name, param_type, checks):
"""Construct code for auto config file for one param value.
Parameters
----------
name : string
Name of the parameter.
param_type : string
Type of the parameter.
checks : list
Constraints of the parameter.
Returns
-------
ret : string
Lines of auto config file with getting and checks of one parameter value.
"""
ret = ""
univar_mapper = {"int": "GetInt", "double": "GetDouble", "bool": "GetBool", "std::string": "GetString"}
if "vector" not in param_type:
ret += " %s(params, \"%s\", &%s);\n" % (univar_mapper[param_type], name, name)
if len(checks) > 0:
for check in checks:
ret += " CHECK(%s %s);\n" % (name, check)
ret += "\n"
else:
ret += " if (GetString(params, \"%s\", &tmp_str)) {\n" % (name)
type2 = param_type.split("<")[1][:-1]
if type2 == "std::string":
ret += " %s = Common::Split(tmp_str.c_str(), ',');\n" % (name)
else:
ret += " %s = Common::StringToArray<%s>(tmp_str, ',');\n" % (name, type2)
ret += " }\n\n"
return ret
|
python
|
def set_one_var_from_string(name, param_type, checks):
"""Construct code for auto config file for one param value.
Parameters
----------
name : string
Name of the parameter.
param_type : string
Type of the parameter.
checks : list
Constraints of the parameter.
Returns
-------
ret : string
Lines of auto config file with getting and checks of one parameter value.
"""
ret = ""
univar_mapper = {"int": "GetInt", "double": "GetDouble", "bool": "GetBool", "std::string": "GetString"}
if "vector" not in param_type:
ret += " %s(params, \"%s\", &%s);\n" % (univar_mapper[param_type], name, name)
if len(checks) > 0:
for check in checks:
ret += " CHECK(%s %s);\n" % (name, check)
ret += "\n"
else:
ret += " if (GetString(params, \"%s\", &tmp_str)) {\n" % (name)
type2 = param_type.split("<")[1][:-1]
if type2 == "std::string":
ret += " %s = Common::Split(tmp_str.c_str(), ',');\n" % (name)
else:
ret += " %s = Common::StringToArray<%s>(tmp_str, ',');\n" % (name, type2)
ret += " }\n\n"
return ret
|
[
"def",
"set_one_var_from_string",
"(",
"name",
",",
"param_type",
",",
"checks",
")",
":",
"ret",
"=",
"\"\"",
"univar_mapper",
"=",
"{",
"\"int\"",
":",
"\"GetInt\"",
",",
"\"double\"",
":",
"\"GetDouble\"",
",",
"\"bool\"",
":",
"\"GetBool\"",
",",
"\"std::string\"",
":",
"\"GetString\"",
"}",
"if",
"\"vector\"",
"not",
"in",
"param_type",
":",
"ret",
"+=",
"\" %s(params, \\\"%s\\\", &%s);\\n\"",
"%",
"(",
"univar_mapper",
"[",
"param_type",
"]",
",",
"name",
",",
"name",
")",
"if",
"len",
"(",
"checks",
")",
">",
"0",
":",
"for",
"check",
"in",
"checks",
":",
"ret",
"+=",
"\" CHECK(%s %s);\\n\"",
"%",
"(",
"name",
",",
"check",
")",
"ret",
"+=",
"\"\\n\"",
"else",
":",
"ret",
"+=",
"\" if (GetString(params, \\\"%s\\\", &tmp_str)) {\\n\"",
"%",
"(",
"name",
")",
"type2",
"=",
"param_type",
".",
"split",
"(",
"\"<\"",
")",
"[",
"1",
"]",
"[",
":",
"-",
"1",
"]",
"if",
"type2",
"==",
"\"std::string\"",
":",
"ret",
"+=",
"\" %s = Common::Split(tmp_str.c_str(), ',');\\n\"",
"%",
"(",
"name",
")",
"else",
":",
"ret",
"+=",
"\" %s = Common::StringToArray<%s>(tmp_str, ',');\\n\"",
"%",
"(",
"name",
",",
"type2",
")",
"ret",
"+=",
"\" }\\n\\n\"",
"return",
"ret"
] |
Construct code for auto config file for one param value.
Parameters
----------
name : string
Name of the parameter.
param_type : string
Type of the parameter.
checks : list
Constraints of the parameter.
Returns
-------
ret : string
Lines of auto config file with getting and checks of one parameter value.
|
[
"Construct",
"code",
"for",
"auto",
"config",
"file",
"for",
"one",
"param",
"value",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L124-L157
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
gen_parameter_description
|
def gen_parameter_description(sections, descriptions, params_rst):
"""Write descriptions of parameters to the documentation file.
Parameters
----------
sections : list
Names of parameters sections.
descriptions : list
Structured descriptions of parameters.
params_rst : string
Path to the file with parameters documentation.
"""
def parse_check(check, reverse=False):
"""Parse the constraint.
Parameters
----------
check : string
String representation of the constraint.
reverse : bool, optional (default=False)
Whether to reverse the sign of the constraint.
Returns
-------
pair : tuple
Parsed constraint in the form of tuple (value, sign).
"""
try:
idx = 1
float(check[idx:])
except ValueError:
idx = 2
float(check[idx:])
if reverse:
reversed_sign = {'<': '>', '>': '<', '<=': '>=', '>=': '<='}
return check[idx:], reversed_sign[check[:idx]]
else:
return check[idx:], check[:idx]
params_to_write = []
for section_name, section_params in zip(sections, descriptions):
params_to_write.append('{0}\n{1}'.format(section_name, '-' * len(section_name)))
for param_desc in section_params:
name = param_desc['name'][0]
default_raw = param_desc['default'][0]
default = default_raw.strip('"') if len(default_raw.strip('"')) > 0 else default_raw
param_type = param_desc.get('type', param_desc['inner_type'])[0].split(':')[-1].split('<')[-1].strip('>')
options = param_desc.get('options', [])
if len(options) > 0:
options_str = ', options: ``{0}``'.format('``, ``'.join([x.strip() for x in options[0].split(',')]))
else:
options_str = ''
aliases = param_desc.get('alias', [])
if len(aliases) > 0:
aliases_str = ', aliases: ``{0}``'.format('``, ``'.join([x.strip() for x in aliases[0].split(',')]))
else:
aliases_str = ''
checks = sorted(param_desc.get('check', []))
checks_len = len(checks)
if checks_len > 1:
number1, sign1 = parse_check(checks[0])
number2, sign2 = parse_check(checks[1], reverse=True)
checks_str = ', constraints: ``{0} {1} {2} {3} {4}``'.format(number2, sign2, name, sign1, number1)
elif checks_len == 1:
number, sign = parse_check(checks[0])
checks_str = ', constraints: ``{0} {1} {2}``'.format(name, sign, number)
else:
checks_str = ''
main_desc = '- ``{0}`` :raw-html:`<a id="{0}" title="Permalink to this parameter" href="#{0}">🔗︎</a>`, default = ``{1}``, type = {2}{3}{4}{5}'.format(name, default, param_type, options_str, aliases_str, checks_str)
params_to_write.append(main_desc)
params_to_write.extend([' ' * 3 * int(desc[0][-1]) + '- ' + desc[1] for desc in param_desc['desc']])
with open(params_rst) as original_params_file:
all_lines = original_params_file.read()
before, start_sep, _ = all_lines.partition('.. start params list\n\n')
_, end_sep, after = all_lines.partition('\n\n.. end params list')
with open(params_rst, "w") as new_params_file:
new_params_file.write(before)
new_params_file.write(start_sep)
new_params_file.write('\n\n'.join(params_to_write))
new_params_file.write(end_sep)
new_params_file.write(after)
|
python
|
def gen_parameter_description(sections, descriptions, params_rst):
"""Write descriptions of parameters to the documentation file.
Parameters
----------
sections : list
Names of parameters sections.
descriptions : list
Structured descriptions of parameters.
params_rst : string
Path to the file with parameters documentation.
"""
def parse_check(check, reverse=False):
"""Parse the constraint.
Parameters
----------
check : string
String representation of the constraint.
reverse : bool, optional (default=False)
Whether to reverse the sign of the constraint.
Returns
-------
pair : tuple
Parsed constraint in the form of tuple (value, sign).
"""
try:
idx = 1
float(check[idx:])
except ValueError:
idx = 2
float(check[idx:])
if reverse:
reversed_sign = {'<': '>', '>': '<', '<=': '>=', '>=': '<='}
return check[idx:], reversed_sign[check[:idx]]
else:
return check[idx:], check[:idx]
params_to_write = []
for section_name, section_params in zip(sections, descriptions):
params_to_write.append('{0}\n{1}'.format(section_name, '-' * len(section_name)))
for param_desc in section_params:
name = param_desc['name'][0]
default_raw = param_desc['default'][0]
default = default_raw.strip('"') if len(default_raw.strip('"')) > 0 else default_raw
param_type = param_desc.get('type', param_desc['inner_type'])[0].split(':')[-1].split('<')[-1].strip('>')
options = param_desc.get('options', [])
if len(options) > 0:
options_str = ', options: ``{0}``'.format('``, ``'.join([x.strip() for x in options[0].split(',')]))
else:
options_str = ''
aliases = param_desc.get('alias', [])
if len(aliases) > 0:
aliases_str = ', aliases: ``{0}``'.format('``, ``'.join([x.strip() for x in aliases[0].split(',')]))
else:
aliases_str = ''
checks = sorted(param_desc.get('check', []))
checks_len = len(checks)
if checks_len > 1:
number1, sign1 = parse_check(checks[0])
number2, sign2 = parse_check(checks[1], reverse=True)
checks_str = ', constraints: ``{0} {1} {2} {3} {4}``'.format(number2, sign2, name, sign1, number1)
elif checks_len == 1:
number, sign = parse_check(checks[0])
checks_str = ', constraints: ``{0} {1} {2}``'.format(name, sign, number)
else:
checks_str = ''
main_desc = '- ``{0}`` :raw-html:`<a id="{0}" title="Permalink to this parameter" href="#{0}">🔗︎</a>`, default = ``{1}``, type = {2}{3}{4}{5}'.format(name, default, param_type, options_str, aliases_str, checks_str)
params_to_write.append(main_desc)
params_to_write.extend([' ' * 3 * int(desc[0][-1]) + '- ' + desc[1] for desc in param_desc['desc']])
with open(params_rst) as original_params_file:
all_lines = original_params_file.read()
before, start_sep, _ = all_lines.partition('.. start params list\n\n')
_, end_sep, after = all_lines.partition('\n\n.. end params list')
with open(params_rst, "w") as new_params_file:
new_params_file.write(before)
new_params_file.write(start_sep)
new_params_file.write('\n\n'.join(params_to_write))
new_params_file.write(end_sep)
new_params_file.write(after)
|
[
"def",
"gen_parameter_description",
"(",
"sections",
",",
"descriptions",
",",
"params_rst",
")",
":",
"def",
"parse_check",
"(",
"check",
",",
"reverse",
"=",
"False",
")",
":",
"\"\"\"Parse the constraint.\n\n Parameters\n ----------\n check : string\n String representation of the constraint.\n reverse : bool, optional (default=False)\n Whether to reverse the sign of the constraint.\n\n Returns\n -------\n pair : tuple\n Parsed constraint in the form of tuple (value, sign).\n \"\"\"",
"try",
":",
"idx",
"=",
"1",
"float",
"(",
"check",
"[",
"idx",
":",
"]",
")",
"except",
"ValueError",
":",
"idx",
"=",
"2",
"float",
"(",
"check",
"[",
"idx",
":",
"]",
")",
"if",
"reverse",
":",
"reversed_sign",
"=",
"{",
"'<'",
":",
"'>'",
",",
"'>'",
":",
"'<'",
",",
"'<='",
":",
"'>='",
",",
"'>='",
":",
"'<='",
"}",
"return",
"check",
"[",
"idx",
":",
"]",
",",
"reversed_sign",
"[",
"check",
"[",
":",
"idx",
"]",
"]",
"else",
":",
"return",
"check",
"[",
"idx",
":",
"]",
",",
"check",
"[",
":",
"idx",
"]",
"params_to_write",
"=",
"[",
"]",
"for",
"section_name",
",",
"section_params",
"in",
"zip",
"(",
"sections",
",",
"descriptions",
")",
":",
"params_to_write",
".",
"append",
"(",
"'{0}\\n{1}'",
".",
"format",
"(",
"section_name",
",",
"'-'",
"*",
"len",
"(",
"section_name",
")",
")",
")",
"for",
"param_desc",
"in",
"section_params",
":",
"name",
"=",
"param_desc",
"[",
"'name'",
"]",
"[",
"0",
"]",
"default_raw",
"=",
"param_desc",
"[",
"'default'",
"]",
"[",
"0",
"]",
"default",
"=",
"default_raw",
".",
"strip",
"(",
"'\"'",
")",
"if",
"len",
"(",
"default_raw",
".",
"strip",
"(",
"'\"'",
")",
")",
">",
"0",
"else",
"default_raw",
"param_type",
"=",
"param_desc",
".",
"get",
"(",
"'type'",
",",
"param_desc",
"[",
"'inner_type'",
"]",
")",
"[",
"0",
"]",
".",
"split",
"(",
"':'",
")",
"[",
"-",
"1",
"]",
".",
"split",
"(",
"'<'",
")",
"[",
"-",
"1",
"]",
".",
"strip",
"(",
"'>'",
")",
"options",
"=",
"param_desc",
".",
"get",
"(",
"'options'",
",",
"[",
"]",
")",
"if",
"len",
"(",
"options",
")",
">",
"0",
":",
"options_str",
"=",
"', options: ``{0}``'",
".",
"format",
"(",
"'``, ``'",
".",
"join",
"(",
"[",
"x",
".",
"strip",
"(",
")",
"for",
"x",
"in",
"options",
"[",
"0",
"]",
".",
"split",
"(",
"','",
")",
"]",
")",
")",
"else",
":",
"options_str",
"=",
"''",
"aliases",
"=",
"param_desc",
".",
"get",
"(",
"'alias'",
",",
"[",
"]",
")",
"if",
"len",
"(",
"aliases",
")",
">",
"0",
":",
"aliases_str",
"=",
"', aliases: ``{0}``'",
".",
"format",
"(",
"'``, ``'",
".",
"join",
"(",
"[",
"x",
".",
"strip",
"(",
")",
"for",
"x",
"in",
"aliases",
"[",
"0",
"]",
".",
"split",
"(",
"','",
")",
"]",
")",
")",
"else",
":",
"aliases_str",
"=",
"''",
"checks",
"=",
"sorted",
"(",
"param_desc",
".",
"get",
"(",
"'check'",
",",
"[",
"]",
")",
")",
"checks_len",
"=",
"len",
"(",
"checks",
")",
"if",
"checks_len",
">",
"1",
":",
"number1",
",",
"sign1",
"=",
"parse_check",
"(",
"checks",
"[",
"0",
"]",
")",
"number2",
",",
"sign2",
"=",
"parse_check",
"(",
"checks",
"[",
"1",
"]",
",",
"reverse",
"=",
"True",
")",
"checks_str",
"=",
"', constraints: ``{0} {1} {2} {3} {4}``'",
".",
"format",
"(",
"number2",
",",
"sign2",
",",
"name",
",",
"sign1",
",",
"number1",
")",
"elif",
"checks_len",
"==",
"1",
":",
"number",
",",
"sign",
"=",
"parse_check",
"(",
"checks",
"[",
"0",
"]",
")",
"checks_str",
"=",
"', constraints: ``{0} {1} {2}``'",
".",
"format",
"(",
"name",
",",
"sign",
",",
"number",
")",
"else",
":",
"checks_str",
"=",
"''",
"main_desc",
"=",
"'- ``{0}`` :raw-html:`<a id=\"{0}\" title=\"Permalink to this parameter\" href=\"#{0}\">🔗︎</a>`, default = ``{1}``, type = {2}{3}{4}{5}'",
".",
"format",
"(",
"name",
",",
"default",
",",
"param_type",
",",
"options_str",
",",
"aliases_str",
",",
"checks_str",
")",
"params_to_write",
".",
"append",
"(",
"main_desc",
")",
"params_to_write",
".",
"extend",
"(",
"[",
"' '",
"*",
"3",
"*",
"int",
"(",
"desc",
"[",
"0",
"]",
"[",
"-",
"1",
"]",
")",
"+",
"'- '",
"+",
"desc",
"[",
"1",
"]",
"for",
"desc",
"in",
"param_desc",
"[",
"'desc'",
"]",
"]",
")",
"with",
"open",
"(",
"params_rst",
")",
"as",
"original_params_file",
":",
"all_lines",
"=",
"original_params_file",
".",
"read",
"(",
")",
"before",
",",
"start_sep",
",",
"_",
"=",
"all_lines",
".",
"partition",
"(",
"'.. start params list\\n\\n'",
")",
"_",
",",
"end_sep",
",",
"after",
"=",
"all_lines",
".",
"partition",
"(",
"'\\n\\n.. end params list'",
")",
"with",
"open",
"(",
"params_rst",
",",
"\"w\"",
")",
"as",
"new_params_file",
":",
"new_params_file",
".",
"write",
"(",
"before",
")",
"new_params_file",
".",
"write",
"(",
"start_sep",
")",
"new_params_file",
".",
"write",
"(",
"'\\n\\n'",
".",
"join",
"(",
"params_to_write",
")",
")",
"new_params_file",
".",
"write",
"(",
"end_sep",
")",
"new_params_file",
".",
"write",
"(",
"after",
")"
] |
Write descriptions of parameters to the documentation file.
Parameters
----------
sections : list
Names of parameters sections.
descriptions : list
Structured descriptions of parameters.
params_rst : string
Path to the file with parameters documentation.
|
[
"Write",
"descriptions",
"of",
"parameters",
"to",
"the",
"documentation",
"file",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L160-L242
|
train
|
Microsoft/LightGBM
|
helpers/parameter_generator.py
|
gen_parameter_code
|
def gen_parameter_code(config_hpp, config_out_cpp):
"""Generate auto config file.
Parameters
----------
config_hpp : string
Path to the config header file.
config_out_cpp : string
Path to the auto config file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
"""
keys, infos = get_parameter_infos(config_hpp)
names = get_names(infos)
alias = get_alias(infos)
str_to_write = r"""/*!
* Copyright (c) 2018 Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See LICENSE file in the project root for license information.
*
* \note
* This file is auto generated by LightGBM\helpers\parameter_generator.py from LightGBM\include\LightGBM\config.h file.
*/
"""
str_to_write += "#include<LightGBM/config.h>\nnamespace LightGBM {\n"
# alias table
str_to_write += "std::unordered_map<std::string, std::string> Config::alias_table({\n"
for pair in alias:
str_to_write += " {\"%s\", \"%s\"},\n" % (pair[0], pair[1])
str_to_write += "});\n\n"
# names
str_to_write += "std::unordered_set<std::string> Config::parameter_set({\n"
for name in names:
str_to_write += " \"%s\",\n" % (name)
str_to_write += "});\n\n"
# from strings
str_to_write += "void Config::GetMembersFromString(const std::unordered_map<std::string, std::string>& params) {\n"
str_to_write += " std::string tmp_str = \"\";\n"
for x in infos:
for y in x:
if "[doc-only]" in y:
continue
param_type = y["inner_type"][0]
name = y["name"][0]
checks = []
if "check" in y:
checks = y["check"]
tmp = set_one_var_from_string(name, param_type, checks)
str_to_write += tmp
# tails
str_to_write += "}\n\n"
str_to_write += "std::string Config::SaveMembersToString() const {\n"
str_to_write += " std::stringstream str_buf;\n"
for x in infos:
for y in x:
if "[doc-only]" in y:
continue
param_type = y["inner_type"][0]
name = y["name"][0]
if "vector" in param_type:
if "int8" in param_type:
str_to_write += " str_buf << \"[%s: \" << Common::Join(Common::ArrayCast<int8_t, int>(%s), \",\") << \"]\\n\";\n" % (name, name)
else:
str_to_write += " str_buf << \"[%s: \" << Common::Join(%s, \",\") << \"]\\n\";\n" % (name, name)
else:
str_to_write += " str_buf << \"[%s: \" << %s << \"]\\n\";\n" % (name, name)
# tails
str_to_write += " return str_buf.str();\n"
str_to_write += "}\n\n"
str_to_write += "} // namespace LightGBM\n"
with open(config_out_cpp, "w") as config_out_cpp_file:
config_out_cpp_file.write(str_to_write)
return keys, infos
|
python
|
def gen_parameter_code(config_hpp, config_out_cpp):
"""Generate auto config file.
Parameters
----------
config_hpp : string
Path to the config header file.
config_out_cpp : string
Path to the auto config file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
"""
keys, infos = get_parameter_infos(config_hpp)
names = get_names(infos)
alias = get_alias(infos)
str_to_write = r"""/*!
* Copyright (c) 2018 Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See LICENSE file in the project root for license information.
*
* \note
* This file is auto generated by LightGBM\helpers\parameter_generator.py from LightGBM\include\LightGBM\config.h file.
*/
"""
str_to_write += "#include<LightGBM/config.h>\nnamespace LightGBM {\n"
# alias table
str_to_write += "std::unordered_map<std::string, std::string> Config::alias_table({\n"
for pair in alias:
str_to_write += " {\"%s\", \"%s\"},\n" % (pair[0], pair[1])
str_to_write += "});\n\n"
# names
str_to_write += "std::unordered_set<std::string> Config::parameter_set({\n"
for name in names:
str_to_write += " \"%s\",\n" % (name)
str_to_write += "});\n\n"
# from strings
str_to_write += "void Config::GetMembersFromString(const std::unordered_map<std::string, std::string>& params) {\n"
str_to_write += " std::string tmp_str = \"\";\n"
for x in infos:
for y in x:
if "[doc-only]" in y:
continue
param_type = y["inner_type"][0]
name = y["name"][0]
checks = []
if "check" in y:
checks = y["check"]
tmp = set_one_var_from_string(name, param_type, checks)
str_to_write += tmp
# tails
str_to_write += "}\n\n"
str_to_write += "std::string Config::SaveMembersToString() const {\n"
str_to_write += " std::stringstream str_buf;\n"
for x in infos:
for y in x:
if "[doc-only]" in y:
continue
param_type = y["inner_type"][0]
name = y["name"][0]
if "vector" in param_type:
if "int8" in param_type:
str_to_write += " str_buf << \"[%s: \" << Common::Join(Common::ArrayCast<int8_t, int>(%s), \",\") << \"]\\n\";\n" % (name, name)
else:
str_to_write += " str_buf << \"[%s: \" << Common::Join(%s, \",\") << \"]\\n\";\n" % (name, name)
else:
str_to_write += " str_buf << \"[%s: \" << %s << \"]\\n\";\n" % (name, name)
# tails
str_to_write += " return str_buf.str();\n"
str_to_write += "}\n\n"
str_to_write += "} // namespace LightGBM\n"
with open(config_out_cpp, "w") as config_out_cpp_file:
config_out_cpp_file.write(str_to_write)
return keys, infos
|
[
"def",
"gen_parameter_code",
"(",
"config_hpp",
",",
"config_out_cpp",
")",
":",
"keys",
",",
"infos",
"=",
"get_parameter_infos",
"(",
"config_hpp",
")",
"names",
"=",
"get_names",
"(",
"infos",
")",
"alias",
"=",
"get_alias",
"(",
"infos",
")",
"str_to_write",
"=",
"r\"\"\"/*!\n * Copyright (c) 2018 Microsoft Corporation. All rights reserved.\n * Licensed under the MIT License. See LICENSE file in the project root for license information.\n *\n * \\note\n * This file is auto generated by LightGBM\\helpers\\parameter_generator.py from LightGBM\\include\\LightGBM\\config.h file.\n */\n\"\"\"",
"str_to_write",
"+=",
"\"#include<LightGBM/config.h>\\nnamespace LightGBM {\\n\"",
"# alias table",
"str_to_write",
"+=",
"\"std::unordered_map<std::string, std::string> Config::alias_table({\\n\"",
"for",
"pair",
"in",
"alias",
":",
"str_to_write",
"+=",
"\" {\\\"%s\\\", \\\"%s\\\"},\\n\"",
"%",
"(",
"pair",
"[",
"0",
"]",
",",
"pair",
"[",
"1",
"]",
")",
"str_to_write",
"+=",
"\"});\\n\\n\"",
"# names",
"str_to_write",
"+=",
"\"std::unordered_set<std::string> Config::parameter_set({\\n\"",
"for",
"name",
"in",
"names",
":",
"str_to_write",
"+=",
"\" \\\"%s\\\",\\n\"",
"%",
"(",
"name",
")",
"str_to_write",
"+=",
"\"});\\n\\n\"",
"# from strings",
"str_to_write",
"+=",
"\"void Config::GetMembersFromString(const std::unordered_map<std::string, std::string>& params) {\\n\"",
"str_to_write",
"+=",
"\" std::string tmp_str = \\\"\\\";\\n\"",
"for",
"x",
"in",
"infos",
":",
"for",
"y",
"in",
"x",
":",
"if",
"\"[doc-only]\"",
"in",
"y",
":",
"continue",
"param_type",
"=",
"y",
"[",
"\"inner_type\"",
"]",
"[",
"0",
"]",
"name",
"=",
"y",
"[",
"\"name\"",
"]",
"[",
"0",
"]",
"checks",
"=",
"[",
"]",
"if",
"\"check\"",
"in",
"y",
":",
"checks",
"=",
"y",
"[",
"\"check\"",
"]",
"tmp",
"=",
"set_one_var_from_string",
"(",
"name",
",",
"param_type",
",",
"checks",
")",
"str_to_write",
"+=",
"tmp",
"# tails",
"str_to_write",
"+=",
"\"}\\n\\n\"",
"str_to_write",
"+=",
"\"std::string Config::SaveMembersToString() const {\\n\"",
"str_to_write",
"+=",
"\" std::stringstream str_buf;\\n\"",
"for",
"x",
"in",
"infos",
":",
"for",
"y",
"in",
"x",
":",
"if",
"\"[doc-only]\"",
"in",
"y",
":",
"continue",
"param_type",
"=",
"y",
"[",
"\"inner_type\"",
"]",
"[",
"0",
"]",
"name",
"=",
"y",
"[",
"\"name\"",
"]",
"[",
"0",
"]",
"if",
"\"vector\"",
"in",
"param_type",
":",
"if",
"\"int8\"",
"in",
"param_type",
":",
"str_to_write",
"+=",
"\" str_buf << \\\"[%s: \\\" << Common::Join(Common::ArrayCast<int8_t, int>(%s), \\\",\\\") << \\\"]\\\\n\\\";\\n\"",
"%",
"(",
"name",
",",
"name",
")",
"else",
":",
"str_to_write",
"+=",
"\" str_buf << \\\"[%s: \\\" << Common::Join(%s, \\\",\\\") << \\\"]\\\\n\\\";\\n\"",
"%",
"(",
"name",
",",
"name",
")",
"else",
":",
"str_to_write",
"+=",
"\" str_buf << \\\"[%s: \\\" << %s << \\\"]\\\\n\\\";\\n\"",
"%",
"(",
"name",
",",
"name",
")",
"# tails",
"str_to_write",
"+=",
"\" return str_buf.str();\\n\"",
"str_to_write",
"+=",
"\"}\\n\\n\"",
"str_to_write",
"+=",
"\"} // namespace LightGBM\\n\"",
"with",
"open",
"(",
"config_out_cpp",
",",
"\"w\"",
")",
"as",
"config_out_cpp_file",
":",
"config_out_cpp_file",
".",
"write",
"(",
"str_to_write",
")",
"return",
"keys",
",",
"infos"
] |
Generate auto config file.
Parameters
----------
config_hpp : string
Path to the config header file.
config_out_cpp : string
Path to the auto config file.
Returns
-------
infos : tuple
Tuple with names and content of sections.
|
[
"Generate",
"auto",
"config",
"file",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/helpers/parameter_generator.py#L245-L320
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/basic.py
|
_load_lib
|
def _load_lib():
"""Load LightGBM library."""
lib_path = find_lib_path()
if len(lib_path) == 0:
return None
lib = ctypes.cdll.LoadLibrary(lib_path[0])
lib.LGBM_GetLastError.restype = ctypes.c_char_p
return lib
|
python
|
def _load_lib():
"""Load LightGBM library."""
lib_path = find_lib_path()
if len(lib_path) == 0:
return None
lib = ctypes.cdll.LoadLibrary(lib_path[0])
lib.LGBM_GetLastError.restype = ctypes.c_char_p
return lib
|
[
"def",
"_load_lib",
"(",
")",
":",
"lib_path",
"=",
"find_lib_path",
"(",
")",
"if",
"len",
"(",
"lib_path",
")",
"==",
"0",
":",
"return",
"None",
"lib",
"=",
"ctypes",
".",
"cdll",
".",
"LoadLibrary",
"(",
"lib_path",
"[",
"0",
"]",
")",
"lib",
".",
"LGBM_GetLastError",
".",
"restype",
"=",
"ctypes",
".",
"c_char_p",
"return",
"lib"
] |
Load LightGBM library.
|
[
"Load",
"LightGBM",
"library",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/basic.py#L25-L32
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/basic.py
|
list_to_1d_numpy
|
def list_to_1d_numpy(data, dtype=np.float32, name='list'):
"""Convert data to 1-D numpy array."""
if is_numpy_1d_array(data):
if data.dtype == dtype:
return data
else:
return data.astype(dtype=dtype, copy=False)
elif is_1d_list(data):
return np.array(data, dtype=dtype, copy=False)
elif isinstance(data, Series):
return data.values.astype(dtype)
else:
raise TypeError("Wrong type({0}) for {1}.\n"
"It should be list, numpy 1-D array or pandas Series".format(type(data).__name__, name))
|
python
|
def list_to_1d_numpy(data, dtype=np.float32, name='list'):
"""Convert data to 1-D numpy array."""
if is_numpy_1d_array(data):
if data.dtype == dtype:
return data
else:
return data.astype(dtype=dtype, copy=False)
elif is_1d_list(data):
return np.array(data, dtype=dtype, copy=False)
elif isinstance(data, Series):
return data.values.astype(dtype)
else:
raise TypeError("Wrong type({0}) for {1}.\n"
"It should be list, numpy 1-D array or pandas Series".format(type(data).__name__, name))
|
[
"def",
"list_to_1d_numpy",
"(",
"data",
",",
"dtype",
"=",
"np",
".",
"float32",
",",
"name",
"=",
"'list'",
")",
":",
"if",
"is_numpy_1d_array",
"(",
"data",
")",
":",
"if",
"data",
".",
"dtype",
"==",
"dtype",
":",
"return",
"data",
"else",
":",
"return",
"data",
".",
"astype",
"(",
"dtype",
"=",
"dtype",
",",
"copy",
"=",
"False",
")",
"elif",
"is_1d_list",
"(",
"data",
")",
":",
"return",
"np",
".",
"array",
"(",
"data",
",",
"dtype",
"=",
"dtype",
",",
"copy",
"=",
"False",
")",
"elif",
"isinstance",
"(",
"data",
",",
"Series",
")",
":",
"return",
"data",
".",
"values",
".",
"astype",
"(",
"dtype",
")",
"else",
":",
"raise",
"TypeError",
"(",
"\"Wrong type({0}) for {1}.\\n\"",
"\"It should be list, numpy 1-D array or pandas Series\"",
".",
"format",
"(",
"type",
"(",
"data",
")",
".",
"__name__",
",",
"name",
")",
")"
] |
Convert data to 1-D numpy array.
|
[
"Convert",
"data",
"to",
"1",
"-",
"D",
"numpy",
"array",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/basic.py#L71-L84
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/basic.py
|
cfloat32_array_to_numpy
|
def cfloat32_array_to_numpy(cptr, length):
"""Convert a ctypes float pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_float)):
return np.fromiter(cptr, dtype=np.float32, count=length)
else:
raise RuntimeError('Expected float pointer')
|
python
|
def cfloat32_array_to_numpy(cptr, length):
"""Convert a ctypes float pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_float)):
return np.fromiter(cptr, dtype=np.float32, count=length)
else:
raise RuntimeError('Expected float pointer')
|
[
"def",
"cfloat32_array_to_numpy",
"(",
"cptr",
",",
"length",
")",
":",
"if",
"isinstance",
"(",
"cptr",
",",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_float",
")",
")",
":",
"return",
"np",
".",
"fromiter",
"(",
"cptr",
",",
"dtype",
"=",
"np",
".",
"float32",
",",
"count",
"=",
"length",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Expected float pointer'",
")"
] |
Convert a ctypes float pointer array to a numpy array.
|
[
"Convert",
"a",
"ctypes",
"float",
"pointer",
"array",
"to",
"a",
"numpy",
"array",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/basic.py#L87-L92
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/basic.py
|
cfloat64_array_to_numpy
|
def cfloat64_array_to_numpy(cptr, length):
"""Convert a ctypes double pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_double)):
return np.fromiter(cptr, dtype=np.float64, count=length)
else:
raise RuntimeError('Expected double pointer')
|
python
|
def cfloat64_array_to_numpy(cptr, length):
"""Convert a ctypes double pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_double)):
return np.fromiter(cptr, dtype=np.float64, count=length)
else:
raise RuntimeError('Expected double pointer')
|
[
"def",
"cfloat64_array_to_numpy",
"(",
"cptr",
",",
"length",
")",
":",
"if",
"isinstance",
"(",
"cptr",
",",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_double",
")",
")",
":",
"return",
"np",
".",
"fromiter",
"(",
"cptr",
",",
"dtype",
"=",
"np",
".",
"float64",
",",
"count",
"=",
"length",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Expected double pointer'",
")"
] |
Convert a ctypes double pointer array to a numpy array.
|
[
"Convert",
"a",
"ctypes",
"double",
"pointer",
"array",
"to",
"a",
"numpy",
"array",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/basic.py#L95-L100
|
train
|
Microsoft/LightGBM
|
python-package/lightgbm/basic.py
|
cint32_array_to_numpy
|
def cint32_array_to_numpy(cptr, length):
"""Convert a ctypes int pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_int32)):
return np.fromiter(cptr, dtype=np.int32, count=length)
else:
raise RuntimeError('Expected int pointer')
|
python
|
def cint32_array_to_numpy(cptr, length):
"""Convert a ctypes int pointer array to a numpy array."""
if isinstance(cptr, ctypes.POINTER(ctypes.c_int32)):
return np.fromiter(cptr, dtype=np.int32, count=length)
else:
raise RuntimeError('Expected int pointer')
|
[
"def",
"cint32_array_to_numpy",
"(",
"cptr",
",",
"length",
")",
":",
"if",
"isinstance",
"(",
"cptr",
",",
"ctypes",
".",
"POINTER",
"(",
"ctypes",
".",
"c_int32",
")",
")",
":",
"return",
"np",
".",
"fromiter",
"(",
"cptr",
",",
"dtype",
"=",
"np",
".",
"int32",
",",
"count",
"=",
"length",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"'Expected int pointer'",
")"
] |
Convert a ctypes int pointer array to a numpy array.
|
[
"Convert",
"a",
"ctypes",
"int",
"pointer",
"array",
"to",
"a",
"numpy",
"array",
"."
] |
8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147
|
https://github.com/Microsoft/LightGBM/blob/8d2ec69f4f685b0ab1c4624d59ee2d3287bb3147/python-package/lightgbm/basic.py#L103-L108
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.