(decoder,
                   output_time_major=False,
                   impute_finished=False,
                   maximum_iterations=None,
                   parallel_iterations=32,
                   swap_memory=False,
                   scope=None,
                   **kwargs)
return final_outputs, final_state, final_sequence_lengths
Perform dynamic decoding with `decoder`.

  Calls initialize() once and step() repeatedly on the Decoder object.

  Args:
    decoder: A `Decoder` instance.
    output_time_major: Python boolean.  Default: `False` (batch major).  If
      `True`, outputs are returned as time major tensors (this mode is faster).
      Otherwise, outputs are returned as batch major tensors (this adds extra
      time to the computation).
    impute_finished: Python boolean.  If `True`, then states for batch
      entries which are marked as finished get copied through and the
      corresponding outputs get zeroed out.  This causes some slowdown at
      each time step, but ensures that the final state and outputs have
      the correct values and that backprop ignores time steps that were
      marked as finished.
    maximum_iterations: `int32` scalar, maximum allowed number of decoding
       steps.  Default is `None` (decode until the decoder is fully done).
    parallel_iterations: Argument passed to `tf.while_loop`.
    swap_memory: Argument passed to `tf.while_loop`.
    scope: Optional variable scope to use.
    **kwargs: dict, other keyword arguments for dynamic_decode. It might contain
      arguments for `BaseDecoder` to initialize, which takes all tensor inputs
      during call().

  Returns:
    `(final_outputs, final_state, final_sequence_lengths)`.

  Raises:
    TypeError: if `decoder` is not an instance of `Decoder`.
    ValueError: if `maximum_iterations` is provided but is not a scalar.
Perform dynamic decoding with `decoder`.
Perform dynamic decoding with decoder .
def dynamic_decode(decoder,
                   output_time_major=False,
                   impute_finished=False,
                   maximum_iterations=None,
                   parallel_iterations=32,
                   swap_memory=False,
                   scope=None,
                   **kwargs):
  """Perform dynamic decoding with `decoder`.

  Calls initialize() once and step() repeatedly on the Decoder object.

  Args:
    decoder: A `Decoder` instance.
    output_time_major: Python boolean.  Default: `False` (batch major).  If
      `True`, outputs are returned as time major tensors (this mode is faster).
      Otherwise, outputs are returned as batch major tensors (this adds extra
      time to the computation).
    impute_finished: Python boolean.  If `True`, then states for batch
      entries which are marked as finished get copied through and the
      corresponding outputs get zeroed out.  This causes some slowdown at
      each time step, but ensures that the final state and outputs have
      the correct values and that backprop ignores time steps that were
      marked as finished.
    maximum_iterations: `int32` scalar, maximum allowed number of decoding
       steps.  Default is `None` (decode until the decoder is fully done).
    parallel_iterations: Argument passed to `tf.while_loop`.
    swap_memory: Argument passed to `tf.while_loop`.
    scope: Optional variable scope to use.
    **kwargs: dict, other keyword arguments for dynamic_decode. It might contain
      arguments for `BaseDecoder` to initialize, which takes all tensor inputs
      during call().

  Returns:
    `(final_outputs, final_state, final_sequence_lengths)`.

  Raises:
    TypeError: if `decoder` is not an instance of `Decoder`.
    ValueError: if `maximum_iterations` is provided but is not a scalar.
  """
  if not isinstance(decoder, (Decoder, BaseDecoder)):
    raise TypeError("Expected decoder to be type Decoder, but saw: %s" %
                    type(decoder))

  with tf.variable_scope(scope, "decoder") as varscope:
    # Enable variable caching if it is safe to do so.
    if _should_cache_variables():
      if varscope.caching_device is None:
        varscope.set_caching_device(lambda op: op.device)

    if maximum_iterations is not None:
      maximum_iterations = tf.convert_to_tensor(
          maximum_iterations, dtype=tf.int32, name="maximum_iterations")
      if maximum_iterations.get_shape().ndims != 0:
        raise ValueError("maximum_iterations must be a scalar")

    if isinstance(decoder, Decoder):
      initial_finished, initial_inputs, initial_state = decoder.initialize()
    else:
      # For BaseDecoder that takes tensor inputs during call.
      decoder_init_input = kwargs.pop("decoder_init_input", None)
      decoder_init_kwargs = kwargs.pop("decoder_init_kwargs", {})
      initial_finished, initial_inputs, initial_state = decoder.initialize(
          decoder_init_input, **decoder_init_kwargs)

    zero_outputs = _create_zero_outputs(decoder.output_size,
                                        decoder.output_dtype,
                                        decoder.batch_size)

    # If we are in an XLA context, we set maximum_iterations on the while loop
    # and set a fixed size for TensorArrays.
    is_xla = control_flow_util.GraphOrParentsInXlaContext(
        tf.get_default_graph())
    if is_xla and maximum_iterations is None:
      raise ValueError("maximum_iterations is required for XLA compilation.")
    if maximum_iterations is not None:
      initial_finished = tf.logical_or(
          initial_finished, 0 >= maximum_iterations)
    initial_sequence_lengths = tf.zeros_like(
        initial_finished, dtype=tf.int32)
    initial_time = tf.constant(0, dtype=tf.int32)

    def _shape(batch_size, from_shape):
      if (not isinstance(from_shape, tf.TensorShape) or
          from_shape.ndims == 0):
        return None
      else:
        batch_size = tensor_util.constant_value(
            tf.convert_to_tensor(batch_size, name="batch_size"))
        return tf.TensorShape([batch_size]).concatenate(from_shape)

    dynamic_size = maximum_iterations is None or not is_xla

    def _create_ta(s, d):
      return tf.TensorArray(
          dtype=d,
          size=0 if dynamic_size else maximum_iterations,
          dynamic_size=dynamic_size,
          element_shape=_shape(decoder.batch_size, s))

    initial_outputs_ta = tf.nest.map_structure(_create_ta, decoder.output_size,
                                               decoder.output_dtype)

    def condition(unused_time, unused_outputs_ta, unused_state, unused_inputs,
                  finished, unused_sequence_lengths):
      return tf.logical_not(tf.reduce_all(finished))

    def body(time, outputs_ta, state, inputs, finished, sequence_lengths):
      """Internal while_loop body.

      Args:
        time: scalar int32 tensor.
        outputs_ta: structure of TensorArray.
        state: (structure of) state tensors and TensorArrays.
        inputs: (structure of) input tensors.
        finished: bool tensor (keeping track of what's finished).
        sequence_lengths: int32 tensor (keeping track of time of finish).

      Returns:
        `(time + 1, outputs_ta, next_state, next_inputs, next_finished,
          next_sequence_lengths)`.
        ```
      """
      (next_outputs, decoder_state, next_inputs,
       decoder_finished) = decoder.step(time, inputs, state)
      decoder_state_sequence_lengths = False
      if decoder.tracks_own_finished:
        next_finished = decoder_finished
        lengths = getattr(decoder_state, "lengths", None)
        if lengths is not None:
          # sequence lengths are provided by decoder_state.lengths; overwrite
          # our sequence lengths.
          decoder_state_sequence_lengths = True
          sequence_lengths = tf.cast(lengths, tf.int32)
      else:
        next_finished = tf.logical_or(decoder_finished, finished)

      if decoder_state_sequence_lengths:
        # Just pass something through the loop; at the next iteration we'll pull
        # the sequence lengths from the decoder_state again.
        next_sequence_lengths = sequence_lengths
      else:
        next_sequence_lengths = tf.where(
            tf.logical_not(finished),
            tf.fill(tf.shape(sequence_lengths), time + 1),
            sequence_lengths)

      tf.nest.assert_same_structure(state, decoder_state)
      tf.nest.assert_same_structure(outputs_ta, next_outputs)
      tf.nest.assert_same_structure(inputs, next_inputs)

      # Zero out output values past finish
      if impute_finished:
        emit = tf.nest.map_structure(
            lambda out, zero: tf.where(finished, zero, out),
            next_outputs,
            zero_outputs)
      else:
        emit = next_outputs

      # Copy through states past finish
      def _maybe_copy_state(new, cur):
        # TensorArrays and scalar states get passed through.
        if isinstance(cur, tf.TensorArray):
          pass_through = True
        else:
          new.set_shape(cur.shape)
          pass_through = (new.shape.ndims == 0)
        return new if pass_through else tf.where(finished, cur, new)

      if impute_finished:
        next_state = tf.nest.map_structure(
            _maybe_copy_state, decoder_state, state)
      else:
        next_state = decoder_state

      outputs_ta = tf.nest.map_structure(lambda ta, out: ta.write(time, out),
                                         outputs_ta, emit)
      return (time + 1, outputs_ta, next_state, next_inputs, next_finished,
              next_sequence_lengths)

    res = tf.while_loop(
        condition,
        body,
        loop_vars=(
            initial_time,
            initial_outputs_ta,
            initial_state,
            initial_inputs,
            initial_finished,
            initial_sequence_lengths,
        ),
        parallel_iterations=parallel_iterations,
        maximum_iterations=maximum_iterations,
        swap_memory=swap_memory)

    final_outputs_ta = res[1]
    final_state = res[2]
    final_sequence_lengths = res[5]

    final_outputs = tf.nest.map_structure(
        lambda ta: ta.stack(), final_outputs_ta)

    try:
      final_outputs, final_state = decoder.finalize(
          final_outputs, final_state, final_sequence_lengths)
    except NotImplementedError:
      pass

    if not output_time_major:
      final_outputs = tf.nest.map_structure(
          _transpose_batch_time, final_outputs)

  return final_outputs, final_state, final_sequence_lengths
def dynamic_decode ( decoder , output_time_major = False , impute_finished = False , maximum_iterations = None , parallel_iterations = 32 , swap_memory = False , scope = None , * * kwargs ) : if not isinstance ( decoder , ( Decoder , BaseDecoder ) ) : raise TypeError ( "Expected decoder to be type Decoder, but saw: %s" % type ( decoder ) ) with tf . variable_scope ( scope , "decoder" ) as varscope : # Enable variable caching if it is safe to do so. if _should_cache_variables ( ) : if varscope . caching_device is None : varscope . set_caching_device ( lambda op : op . device ) if maximum_iterations is not None : maximum_iterations = tf . convert_to_tensor ( maximum_iterations , dtype = tf . int32 , name = "maximum_iterations" ) if maximum_iterations . get_shape ( ) . ndims != 0 : raise ValueError ( "maximum_iterations must be a scalar" ) if isinstance ( decoder , Decoder ) : initial_finished , initial_inputs , initial_state = decoder . initialize ( ) else : # For BaseDecoder that takes tensor inputs during call. decoder_init_input = kwargs . pop ( "decoder_init_input" , None ) decoder_init_kwargs = kwargs . pop ( "decoder_init_kwargs" , { } ) initial_finished , initial_inputs , initial_state = decoder . initialize ( decoder_init_input , * * decoder_init_kwargs ) zero_outputs = _create_zero_outputs ( decoder . output_size , decoder . output_dtype , decoder . batch_size ) # If we are in an XLA context, we set maximum_iterations on the while loop # and set a fixed size for TensorArrays. is_xla = control_flow_util . GraphOrParentsInXlaContext ( tf . get_default_graph ( ) ) if is_xla and maximum_iterations is None : raise ValueError ( "maximum_iterations is required for XLA compilation." ) if maximum_iterations is not None : initial_finished = tf . logical_or ( initial_finished , 0 >= maximum_iterations ) initial_sequence_lengths = tf . zeros_like ( initial_finished , dtype = tf . int32 ) initial_time = tf . constant ( 0 , dtype = tf . int32 ) def _shape ( batch_size , from_shape ) : if ( not isinstance ( from_shape , tf . TensorShape ) or from_shape . ndims == 0 ) : return None else : batch_size = tensor_util . constant_value ( tf . convert_to_tensor ( batch_size , name = "batch_size" ) ) return tf . TensorShape ( [ batch_size ] ) . concatenate ( from_shape ) dynamic_size = maximum_iterations is None or not is_xla def _create_ta ( s , d ) : return tf . TensorArray ( dtype = d , size = 0 if dynamic_size else maximum_iterations , dynamic_size = dynamic_size , element_shape = _shape ( decoder . batch_size , s ) ) initial_outputs_ta = tf . nest . map_structure ( _create_ta , decoder . output_size , decoder . output_dtype ) def condition ( unused_time , unused_outputs_ta , unused_state , unused_inputs , finished , unused_sequence_lengths ) : return tf . logical_not ( tf . reduce_all ( finished ) ) def body ( time , outputs_ta , state , inputs , finished , sequence_lengths ) : """Internal while_loop body.

      Args:
        time: scalar int32 tensor.
        outputs_ta: structure of TensorArray.
        state: (structure of) state tensors and TensorArrays.
        inputs: (structure of) input tensors.
        finished: bool tensor (keeping track of what's finished).
        sequence_lengths: int32 tensor (keeping track of time of finish).

      Returns:
        `(time + 1, outputs_ta, next_state, next_inputs, next_finished,
          next_sequence_lengths)`.
        ```
      """ ( next_outputs , decoder_state , next_inputs , decoder_finished ) = decoder . step ( time , inputs , state ) decoder_state_sequence_lengths = False if decoder . tracks_own_finished : next_finished = decoder_finished lengths = getattr ( decoder_state , "lengths" , None ) if lengths is not None : # sequence lengths are provided by decoder_state.lengths; overwrite # our sequence lengths. decoder_state_sequence_lengths = True sequence_lengths = tf . cast ( lengths , tf . int32 ) else : next_finished = tf . logical_or ( decoder_finished , finished ) if decoder_state_sequence_lengths : # Just pass something through the loop; at the next iteration we'll pull # the sequence lengths from the decoder_state again. next_sequence_lengths = sequence_lengths else : next_sequence_lengths = tf . where ( tf . logical_not ( finished ) , tf . fill ( tf . shape ( sequence_lengths ) , time + 1 ) , sequence_lengths ) tf . nest . assert_same_structure ( state , decoder_state ) tf . nest . assert_same_structure ( outputs_ta , next_outputs ) tf . nest . assert_same_structure ( inputs , next_inputs ) # Zero out output values past finish if impute_finished : emit = tf . nest . map_structure ( lambda out , zero : tf . where ( finished , zero , out ) , next_outputs , zero_outputs ) else : emit = next_outputs # Copy through states past finish def _maybe_copy_state ( new , cur ) : # TensorArrays and scalar states get passed through. if isinstance ( cur , tf . TensorArray ) : pass_through = True else : new . set_shape ( cur . shape ) pass_through = ( new . shape . ndims == 0 ) return new if pass_through else tf . where ( finished , cur , new ) if impute_finished : next_state = tf . nest . map_structure ( _maybe_copy_state , decoder_state , state ) else : next_state = decoder_state outputs_ta = tf . nest . map_structure ( lambda ta , out : ta . write ( time , out ) , outputs_ta , emit ) return ( time + 1 , outputs_ta , next_state , next_inputs , next_finished , next_sequence_lengths ) res = tf . while_loop ( condition , body , loop_vars = ( initial_time , initial_outputs_ta , initial_state , initial_inputs , initial_finished , initial_sequence_lengths , ) , parallel_iterations = parallel_iterations , maximum_iterations = maximum_iterations , swap_memory = swap_memory ) final_outputs_ta = res [ 1 ] final_state = res [ 2 ] final_sequence_lengths = res [ 5 ] final_outputs = tf . nest . map_structure ( lambda ta : ta . stack ( ) , final_outputs_ta ) try : final_outputs , final_state = decoder . finalize ( final_outputs , final_state , final_sequence_lengths ) except NotImplementedError : pass if not output_time_major : final_outputs = tf . nest . map_structure ( _transpose_batch_time , final_outputs ) return final_outputs , final_state , final_sequence_lengths