# limitations under the License. # ============================================================================== -# usage: bash tools/update_release_version.sh <release_number>+# usage: bash tools/update_release_version.sh <list_of_release_numbers>+# e.g. bash tools/update_release_version.sh 2.3.0 2.3.1 

 def __init__(          An example: -        ```-        tiled_encoder_outputs = tfa.seq2seq.tile_batch(-            encoder_outputs, multiplier=beam_width)-        tiled_encoder_final_state = tfa.seq2seq.tile_batch(-            encoder_final_state, multiplier=beam_width)-        tiled_sequence_length = tfa.seq2seq.tile_batch(-            sequence_length, multiplier=beam_width)-        attention_mechanism = MyFavoriteAttentionMechanism(-            num_units=attention_depth,-            memory=tiled_inputs,-            memory_sequence_length=tiled_sequence_length)-        attention_cell = AttentionWrapper(cell, attention_mechanism, ...)-        decoder_initial_state = attention_cell.get_initial_state(-            batch_size=true_batch_size * beam_width, dtype=dtype)-        decoder_initial_state = decoder_initial_state.clone(-            cell_state=tiled_encoder_final_state)-        ```+        >>> batch_size = 1+        >>> beam_width = 5+        >>> sequence_length = [5]

 def __init__(          An example: -        ```-        tiled_encoder_outputs = tfa.seq2seq.tile_batch(-            encoder_outputs, multiplier=beam_width)-        tiled_encoder_final_state = tfa.seq2seq.tile_batch(-            encoder_final_state, multiplier=beam_width)-        tiled_sequence_length = tfa.seq2seq.tile_batch(-            sequence_length, multiplier=beam_width)-        attention_mechanism = MyFavoriteAttentionMechanism(-            num_units=attention_depth,-            memory=tiled_inputs,-            memory_sequence_length=tiled_sequence_length)-        attention_cell = AttentionWrapper(cell, attention_mechanism, ...)-        decoder_initial_state = attention_cell.get_initial_state(-            batch_size=true_batch_size * beam_width, dtype=dtype)-        decoder_initial_state = decoder_initial_state.clone(-            cell_state=tiled_encoder_final_state)-        ```+        >>> batch_size = 1+        >>> beam_width = 5+        >>> sequence_length = [5]+        >>> encoder_outputs = tf.random.uniform(shape=(batch_size, 5, 10))+        >>> encoder_final_state = [tf.zeros((1, 10)), tf.zeros((1, 10))]

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> batch_size = 1+        >>> memory = tf.random.normal(shape=[batch_size, 3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]

 def __init__(          An example: -        ```-        tiled_encoder_outputs = tfa.seq2seq.tile_batch(-            encoder_outputs, multiplier=beam_width)-        tiled_encoder_final_state = tfa.seq2seq.tile_batch(-            encoder_final_state, multiplier=beam_width)-        tiled_sequence_length = tfa.seq2seq.tile_batch(-            sequence_length, multiplier=beam_width)-        attention_mechanism = MyFavoriteAttentionMechanism(-            num_units=attention_depth,-            memory=tiled_inputs,-            memory_sequence_length=tiled_sequence_length)-        attention_cell = AttentionWrapper(cell, attention_mechanism, ...)-        decoder_initial_state = attention_cell.get_initial_state(-            batch_size=true_batch_size * beam_width, dtype=dtype)-        decoder_initial_state = decoder_initial_state.clone(-            cell_state=tiled_encoder_final_state)-        ```+        >>> batch_size = 1+        >>> beam_width = 5+        >>> sequence_length = [5]+        >>> encoder_outputs = tf.random.uniform(shape=(batch_size, 5, 10))+        >>> encoder_final_states = [tf.zeros((1, 10)), tf.zeros((1, 10))]

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> batch_size = 1+        >>> memory = tf.random.normal(shape=[1, 3, 100])

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> batch_size = 1+        >>> memory = tf.random.normal(shape=[1, 3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> batch_size = 1+        >>> memory = tf.random.normal(shape=[1, 3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)+        >>> attention_mechanism = tfa.seq2seq.LuongAttention(100, memory=memory, memory_sequence_length=[3] * batch_size)+        >>> decoder_rnn_cell = tfa.seq2seq.AttentionWrapper(decoder_rnn_cell, attention_mechanism, attention_layer_size=10)+        >>> decoder_initial_state = decoder_rnn_cell.get_initial_state(batch_size=batch_size, dtype=tf.float32)

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> batch_size = 1+        >>> memory = tf.random.normal(shape=[1, 3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)+        >>> attention_mechanism = tfa.seq2seq.LuongAttention(100, memory=memory, memory_sequence_length=[3] * batch_size)+        >>> decoder_rnn_cell = tfa.seq2seq.AttentionWrapper(decoder_rnn_cell, attention_mechanism, attention_layer_size=10)

 def __init__(          An example: -        ```-        tiled_encoder_outputs = tfa.seq2seq.tile_batch(-            encoder_outputs, multiplier=beam_width)-        tiled_encoder_final_state = tfa.seq2seq.tile_batch(-            encoder_final_state, multiplier=beam_width)-        tiled_sequence_length = tfa.seq2seq.tile_batch(-            sequence_length, multiplier=beam_width)-        attention_mechanism = MyFavoriteAttentionMechanism(-            num_units=attention_depth,-            memory=tiled_inputs,-            memory_sequence_length=tiled_sequence_length)-        attention_cell = AttentionWrapper(cell, attention_mechanism, ...)-        decoder_initial_state = attention_cell.get_initial_state(-            batch_size=true_batch_size * beam_width, dtype=dtype)-        decoder_initial_state = decoder_initial_state.clone(-            cell_state=tiled_encoder_final_state)-        ```+        >>> batch_size = 1+        >>> beam_width = 5+        >>> sequence_length = [5]+        >>> encoder_outputs = tf.random.uniform(shape=(batch_size, 5, 10))+        >>> encoder_final_states = [tf.zeros((1, 10)), tf.zeros((1, 10))]+        >>> tiled_encoder_outputs = tfa.seq2seq.tile_batch(encoder_outputs, multiplier=beam_width)+        >>> tiled_encoder_final_state = tfa.seq2seq.tile_batch(encoder_final_state, multiplier=beam_width)+        >>> tiled_sequence_length = tfa.seq2seq.tile_batch(sequence_length, multiplier=beam_width)+        >>> attention_mechanism = tfa.seq2seq.BahdanauAttention(10, memory=tiled_encoder_outputs, memory_sequence_length=tiled_sequence_length)+        >>> attention_cell = tfa.seq2seq.AttentionWrapper(tf.keras.layers.LSTMCell(10), attention_mechanism)+        >>> decoder_initial_state = attention_cell.get_initial_state(batch_size=true_batch_size * beam_width, dtype=tf.float32)

 def __init__(          An example: -        ```-        tiled_encoder_outputs = tfa.seq2seq.tile_batch(-            encoder_outputs, multiplier=beam_width)-        tiled_encoder_final_state = tfa.seq2seq.tile_batch(-            encoder_final_state, multiplier=beam_width)-        tiled_sequence_length = tfa.seq2seq.tile_batch(-            sequence_length, multiplier=beam_width)-        attention_mechanism = MyFavoriteAttentionMechanism(-            num_units=attention_depth,-            memory=tiled_inputs,-            memory_sequence_length=tiled_sequence_length)-        attention_cell = AttentionWrapper(cell, attention_mechanism, ...)-        decoder_initial_state = attention_cell.get_initial_state(-            batch_size=true_batch_size * beam_width, dtype=dtype)-        decoder_initial_state = decoder_initial_state.clone(-            cell_state=tiled_encoder_final_state)-        ```+        >>> vocab_size = 10+        >>> max_time = 16+        >>> batch_size = 2+        >>> emb_dim = 20+        >>> cell_dim = 5+        >>> attention_dim = cell_dim+        >>> beam_width = 3+        >>> hidden_size = 7++        >>> inputs = tf.random.uniform([batch_size, max_time, emb_dim], maxval=1., dtype=tf.float32)+        >>> embedding = tf.random.uniform([vocab_size, emb_dim], maxval=1., dtype=tf.float32)++        # make encoder++        >>> lstm = tf.keras.layers.LSTMCell(hidden_size)+        >>> lstmW = tf.keras.layers.RNN(lstm, return_sequences=True, return_state=True)+        >>> whole_encoder_seq_output, final_encoder_state, final_carry_state = lstmW(inputs)+        >>> #print("final_state_ibia", final_encoder_state)+        >>> #when beamsearch is used+        >>> tiled_encoder_output = tfa.seq2seq.tile_batch(whole_encoder_seq_output, multiplier=beam_width)+        >>> tiled_encoder_final_state = tfa.seq2seq.tile_batch(final_encoder_state, multiplier=beam_width)+        >>> encoder_initial_state = lstmW.get_initial_state(inputs)+        >>> tiled_encoder_initial_state = tfa.seq2seq.tile_batch(encoder_initial_state, multiplier=beam_width)++        #make decoder++        >>> memory = tiled_encoder_output++        #attention wrapper++        >>> attn_cells = tfa.seq2seq.AttentionWrapper(+        ... lstm,+        ... attention_mechanism=tfa.seq2seq.BahdanauAttention(units=hidden_size, memory=memory, memory_sequence_length=batch_size*beam_width),+        ... attention_layer_size=hidden_size,+        ... initial_cell_state=tiled_encoder_final_state+        ... )+        >>> decoder_initial_state= attn_cells.get_initial_state(batch_size=batch_size*beam_width, dtype= tf.float32)+        >>> decoder_initial_state = decoder_initial_state.clone(cell_state=tiled_encoder_final_state)++        #make predictions++        >>> decoder = tfa.seq2seq.BeamSearchDecoder(+        ... cell=attn_cells,+        ... beam_width=batch_size*beam_width,+        ... output_layer=tf.keras.layers.Dense(hidden_size, name='output_proj')+        ...   ) #second structure decoder++        >>> start_tokens = tf.zeros((batch_size,), dtype=tf.int32)+        >>> decoder.initialize(embedding=embedding, start_tokens= start_tokens ,end_token= 1, initial_state=decoder_initial_state)#first structure decoder_initial_state+        >>> #final_outputs, final_state, final_sequence_lengths = tfa.seq2seq.dynamic_decode(decoder=decoder, impute_finished=False, maximum_iterations= 100)

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> BATCH_SIZE = 1

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> BATCH_SIZE = 1+        >>> memory = tf.random.normal(shape =[1,3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)+        >>> attention_mechanism = tfa.seq2seq.LuongAttention(100,memory=memory, memory_sequence_length=BATCH_SIZE*[3])

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> BATCH_SIZE = 1+        >>> memory = tf.random.normal(shape =[1,3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)+        >>> attention_mechanism = tfa.seq2seq.LuongAttention(100,memory=memory, memory_sequence_length=BATCH_SIZE*[3])+        >>> rnn_cell = tfa.seq2seq.AttentionWrapper(decoder_rnn_cell, attention_mechanism, attention_layer_size=10)

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> BATCH_SIZE = 1+        >>> memory = tf.random.normal(shape =[1,3, 100])+        >>> encoder_state = [tf.zeros((1, 100)), tf.zeros((1, 100))]+        >>> decoder_rnn_cell = tf.keras.layers.LSTMCell(100)+        >>> attention_mechanism = tfa.seq2seq.LuongAttention(100,memory=memory, memory_sequence_length=BATCH_SIZE*[3])+        >>> rnn_cell = tfa.seq2seq.AttentionWrapper(decoder_rnn_cell, attention_mechanism, attention_layer_size=10)+        >>> decoder_initial_state = rnn_cell.get_initial_state(batch_size=BATCH_SIZE, dtype=tf.float32)

 def clone(self, **kwargs):          Example: -        ```python-        initial_state = attention_wrapper.get_initial_state(-            batch_size=..., dtype=...)-        initial_state = initial_state.clone(cell_state=encoder_state)-        ```+        >>> BATCH_SIZE = 1+        >>> memory = tf.random.normal(shape =[1,3, 100])

 class MovingAverage(AveragedOptimizerWrapper):     Empirically it has been found that using the moving average of the trained     parameters of a deep network is better than using its trained parameters     directly. This optimizer allows you to compute this moving average and swap+    raise app.UsageError('Too many command-line arguments.')

 def get_config(self):         return {**base_config, **config}      def _create_slots(self, var_list):-        self._optimizer._create_slots(-            var_list=var_list-        )  # pylint: disable=protected-access+        self._optimizer._create_slots(var_list=var_list)  # pylint: disable=protected-access

 def test_dynamic_decay():     np.testing.assert_allclose(ema_var0.read_value(), [0.64, 1.64])  [email protected]("maybe_run_functions_eagerly")[email protected]_device([tf.distribute.MirroredStrategy])+def test_swap_weight_no_shadow_copy():

  import tensorflow as tf -MIN_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.2.0"-MAX_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.3.0"+MIN_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.3.0"+MAX_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.4.0"

  import tensorflow as tf -MIN_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.2.0"-MAX_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.3.0"+MIN_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.3.0"+MAX_TF_VERSION_FOR_ABI_COMPATIBILITY = "2.4.0"

 class MultiOptimizer(tf.keras.optimizers.Optimizer):     """Multi Optimizer Wrapper for Discriminative Layer Training. -    Creates a wrapper around a set of instantiated optimizer layer pairs. Generally useful for transfer learning-    of deep networks.+    Creates a wrapper around a set of instantiated optimizer layer pairs.+    Generally useful for transfer learning of deep networks. -    Each optimizer will optimize only the weights associated with its paired layer. This can be used-    to implement discriminative layer training by assigning different learning rates to each optimizer-    layer pair. (Optimizer, list(Layers)) pairs are also supported. Please note that the layers must be-    instantiated before instantiating the optimizer.+    Each optimizer will optimize only the weights associated with its paired layer.+    This can be used to implement discriminative layer training by assigning+    different learning rates to each optimizer layer pair.+    `(tf.keras.optimizers.Optimizer, List[tf.keras.layers.Layer])` pairs are also supported.