B ӻd&@sVdZddlZddlmZddlmZddlmZddlmZddlm Z ddlm Z dd lm Z dd lm Z dd l mZdd l mZdd lmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddlmZddl m!Z!dZ"dZ#dZ$dZ%dZ&dZ'dZ(dZ)d Z*d!d"Z+Gd#d$d$e,Z-e!d%gd&Gd'd(d(ej.Z.e!d)gd&Gd*d+d+ej/ej0Z0d,d-Z1d.d/Z2d0d1Z3e!d2gd&Gd3d4d4ej4Z4e!d5gd&Gd6d7d7ej/ej5Z5dSd9d:Z6d;d<Z7d=d>Z8d?d@Z9dAdBZ:dCdDZ;dEdFZdKdLZ?dMdNZ@dOdPZAdQdRZBdS)TzRecurrent layers for TF 2.N)context)function)get_device_name)config) constant_op)device)dtypes)ops) activations)backend) InputSpec) recurrent) array_ops)control_flow_ops)gen_cudnn_rnn_ops)math_ops)nn) state_ops) variables) sysconfig) tf_logging) keras_exportZapi_implementsZapi_preferred_deviceZCPUGPUz4Layer %s will use cuDNN kernels when running on GPU.zLayer %s will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.cCsdS)NFrrr]/var/www/html/venv/lib/python3.7/site-packages/tensorflow/python/keras/layers/recurrent_v2.py _use_new_codeBsrc@s eZdZdZddZddZdS) _DefunWrapperz;A wrapper with no deep copy of the Defun in LSTM/GRU layer.c Cs|||_||_||_|jdkr,td|jd|jd|jt|jdtti}|jdkrbt }nt }t j ||dd|_ dS) N)lstmgruz>Defun wrapper only applies to LSTM and GRU layer, but given {} time_major go_backwards_rF) attributes autograph)r!r" layer_name ValueErrorformat_FUNCTION_API_NAME_ATTRIBUTEstruuiduuid4lstm_with_backend_selectiongru_with_backend_selectionrdefun_with_attributes defun_layer)selfr!r"r&supportive_attributesZ layer_funcrrr__init__Ks    z_DefunWrapper.__init__cCs&t||j|j|j}||t|<|S)N)typer!r"r&id)r1memoZ new_wrapperrrr __deepcopy__bs z_DefunWrapper.__deepcopy__N)__name__ __module__ __qualname____doc__r3r7rrrrrHsrzkeras.layers.GRUCell)Zv1cs"eZdZdZd fd d ZZS) GRUCella Cell class for the GRU layer. See [the Keras RNN API guide](https://www.tensorflow.org/guide/keras/rnn) for details about the usage of RNN API. This class processes one step within the whole time sequence input, whereas `tf.keras.layer.GRU` processes the whole sequence. For example: >>> inputs = tf.random.normal([32, 10, 8]) >>> rnn = tf.keras.layers.RNN(tf.keras.layers.GRUCell(4)) >>> output = rnn(inputs) >>> print(output.shape) (32, 4) >>> rnn = tf.keras.layers.RNN( ... tf.keras.layers.GRUCell(4), ... return_sequences=True, ... return_state=True) >>> whole_sequence_output, final_state = rnn(inputs) >>> print(whole_sequence_output.shape) (32, 10, 4) >>> print(final_state.shape) (32, 4) Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass None, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean, (default `True`), whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `glorot_uniform`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `orthogonal`. bias_initializer: Initializer for the bias vector. Default: `zeros`. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. reset_after: GRU convention (whether to apply reset gate after or before matrix multiplication). False = "before", True = "after" (default and CuDNN compatible). Call arguments: inputs: A 2D tensor, with shape of `[batch, feature]`. states: A 2D tensor with shape of `[batch, units]`, which is the state from the previous time step. For timestep 0, the initial state provided by user will be feed to cell. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. Only relevant when `dropout` or `recurrent_dropout` is used. tanhsigmoidTglorot_uniform orthogonalzerosNc sFtt|j|f|||||||| | | | | |||dd|d|dS)Nimplementationr) activationrecurrent_activationuse_biaskernel_initializerrecurrent_initializerbias_initializerkernel_regularizerrecurrent_regularizerbias_regularizerkernel_constraintrecurrent_constraintbias_constraintdropoutrecurrent_dropoutrC reset_after)superr<r3pop)r1unitsrDrErFrGrHrIrJrKrLrMrNrOrPrQrRkwargs) __class__rrr3s&  zGRUCell.__init__)r=r>Tr?r@rANNNNNNrBrBT)r8r9r:r;r3 __classcell__rr)rWrr<is Gr<zkeras.layers.GRUcs4eZdZdZdfd d Zdd dZddZZS)GRUaXGated Recurrent Unit - Cho et al. 2014. See [the Keras RNN API guide](https://www.tensorflow.org/guide/keras/rnn) for details about the usage of RNN API. Based on available runtime hardware and constraints, this layer will choose different implementations (cuDNN-based or pure-TensorFlow) to maximize the performance. If a GPU is available and all the arguments to the layer meet the requirement of the CuDNN kernel (see below for details), the layer will use a fast cuDNN implementation. The requirements to use the cuDNN implementation are: 1. `activation` == `tanh` 2. `recurrent_activation` == `sigmoid` 3. `recurrent_dropout` == 0 4. `unroll` is `False` 5. `use_bias` is `True` 6. `reset_after` is `True` 7. Inputs, if use masking, are strictly right-padded. 8. Eager execution is enabled in the outermost context. There are two variants of the GRU implementation. The default one is based on [v3](https://arxiv.org/abs/1406.1078v3) and has reset gate applied to hidden state before matrix multiplication. The other one is based on [original](https://arxiv.org/abs/1406.1078v1) and has the order reversed. The second variant is compatible with CuDNNGRU (GPU-only) and allows inference on CPU. Thus it has separate biases for `kernel` and `recurrent_kernel`. To use this variant, set `'reset_after'=True` and `recurrent_activation='sigmoid'`. For example: >>> inputs = tf.random.normal([32, 10, 8]) >>> gru = tf.keras.layers.GRU(4) >>> output = gru(inputs) >>> print(output.shape) (32, 4) >>> gru = tf.keras.layers.GRU(4, return_sequences=True, return_state=True) >>> whole_sequence_output, final_state = gru(inputs) >>> print(whole_sequence_output.shape) (32, 10, 4) >>> print(final_state.shape) (32, 4) Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean, (default `True`), whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `glorot_uniform`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `orthogonal`. bias_initializer: Initializer for the bias vector. Default: `zeros`. kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. activity_regularizer: Regularizer function applied to the output of the layer (its "activation"). Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. return_sequences: Boolean. Whether to return the last output in the output sequence, or the full sequence. Default: `False`. return_state: Boolean. Whether to return the last state in addition to the output. Default: `False`. go_backwards: Boolean (default `False`). If True, process the input sequence backwards and return the reversed sequence. stateful: Boolean (default False). If True, the last state for each sample at index i in a batch will be used as initial state for the sample of index i in the following batch. unroll: Boolean (default False). If True, the network will be unrolled, else a symbolic loop will be used. Unrolling can speed-up a RNN, although it tends to be more memory-intensive. Unrolling is only suitable for short sequences. time_major: The shape format of the `inputs` and `outputs` tensors. If True, the inputs and outputs will be in shape `[timesteps, batch, feature]`, whereas in the False case, it will be `[batch, timesteps, feature]`. Using `time_major = True` is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form. reset_after: GRU convention (whether to apply reset gate after or before matrix multiplication). False = "before", True = "after" (default and CuDNN compatible). Call arguments: inputs: A 3D tensor, with shape `[batch, timesteps, feature]`. mask: Binary tensor of shape `[samples, timesteps]` indicating whether a given timestep should be masked (optional, defaults to `None`). An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. This argument is passed to the cell when calling it. This is only relevant if `dropout` or `recurrent_dropout` is used (optional, defaults to `None`). initial_state: List of initial state tensors to be passed to the first call of the cell (optional, defaults to `None` which causes creation of zero-filled initial state tensors). r=r>Tr?r@rANFc s|dd|_tt|j|f|||||||| | | | | ||||dd|||||||d||jtjtjfko|j tj tj fko|dko| o|o|ot |_ tdr|j rtt|jntt|jtrt||d|_dS) Nreturn_runtimeFrCr)rDrErFrGrHrIrJrKrLactivity_regularizerrMrNrOrPrQrCreturn_sequences return_stater"statefulunrollr!rRrrr )rT_return_runtimerSrYr3rDr r=rrEr>r #executing_eagerly_outside_functions_could_use_gpu_kernelrlist_logical_devicesloggingdebug_CUDNN_AVAILABLE_MSGnamewarning_CUDNN_NOT_AVAILABLE_MSGrr_defun_wrapper)r1rUrDrErFrGrHrIrJrKrLr\rMrNrOrPrQr]r^r"r_r`r!rRrV)rWrrr3ZsJ   z GRU.__init__c sjt|\}}|dk }||||d\}}}t|trH|d}t|}jr`|dn|d} |srjsd|i j fdd} tj | ||dj |j |dk r|n| jjd \} } } tt}n|||||\} } }} jrtjd| dg}|jr8tj|| |j d}n| }jrR|gt| Sjrb||fS|SdS)Nrrtrainingcsj||fS)N)cell) cell_inputs cell_states)rVr1rrstepszGRU.call..step) constantsr"maskr` input_lengthr!zero_output_for_mask)r")r convert_inputs_if_ragged_validate_args_if_ragged_process_inputs isinstancelist int_shaper!rc_maybe_reset_cell_dropout_maskrmrnnr"r`rt_runtime_RUNTIME_UNKNOWN_defun_gru_callr_rassignstates add_updater]maybe_convert_to_raggedr^ra)r1inputsrrrl initial_state row_lengthsis_ragged_inputr# input_shape timestepsrp last_outputoutputsrruntimeupdatesoutputr)rVr1rcallsL       zGRU.callc Csv||j||dd}|dk r,||d}tr|t|dt|jjt|jjt|jj||j|j ||j d }|j j f|\}} } } n|t|dt|jjt|jjt|jj||j|j |d } | } | d|j itrRt}|tks|dko"tdo"|dkp"t||j}|r>tf| \}} } } ntf| \}} } } ntf| \}} } } | g}|| | |fS)N)countr) rinit_hkernelrecurrent_kernelbiasrrr!r"sequence_lengthsrt) rrrrrrrr!r"rrtr)reset_dropout_maskget_dropout_mask_for_cellr_read_variable_valuermrrrr!r"rtrkr0copyupdaterexecuting_eagerly_get_context_device_type_GPU_DEVICE_NAMErrdis_cudnn_supported_inputsgpu_gru standard_grur.)r1rrrlrrr dropout_maskZ gru_kwargsrrnew_hrZgpu_gru_kwargsZnormal_gru_kwargs device_type can_use_gpurrrrrsR             zGRU._defun_gru_call)r=r>Tr?r@rANNNNNNNrZrZFFFFFFT)NNN)r8r9r:r;r3rrrXrr)rWrrYs21 ;rYc  st|} |r| dn| d} t|\fdd} tj| ||gdd||||dk r`|n| | d \} }}| ||dttfS)aGRU with standard kernel implementation. This implementation can be run on all types of hardware. This implementation lifts out all the layer weights and make them function parameters. It has same number of tensor input params as the CuDNN counterpart. The RNN step logic has been simplified, eg dropout and mask is removed since CuDNN implementation does not support that. Args: inputs: Input tensor of GRU layer. init_h: Initial state tensor for the cell output. kernel: Weights for cell kernel. recurrent_kernel: Weights for cell recurrent kernel. bias: Weights for cell kernel bias and recurrent bias. The bias contains the combined input_bias and recurrent_bias. mask: Binary tensor of shape `(samples, timesteps)` indicating whether a given timestep should be masked. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: Boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. zero_output_for_mask: Boolean, whether to output zero for masked timestep. Returns: last_output: output tensor for the last timestep, which has shape [batch, units]. outputs: output tensor for all timesteps, which has shape [batch, time, units]. state_0: the cell output, which has same shape as init_h. runtime: constant string tensor which indicate real runtime hardware. This value is for testing purpose and should be used by user. rrcs|d}t|}t|}tj|ddd\}}}t|}t|}tj|ddd\}} } t||} t|| } t|| | } | |d| | }||gfS)z5Step function that will be used by Keras RNN backend.rrr)axis)r dotbias_addrsplitrr>r=)rnroh_tm1Zmatrix_xZx_zZx_rZx_hZ matrix_innerZ recurrent_zZ recurrent_rZ recurrent_hzrhhh) input_biasrrecurrent_biasrrrrpKs    zstandard_gru..stepNF)rqr`r!rrr"rsrt)r rzrZunstackr|r} _RUNTIME_CPU)rrrrrrrr!r"rrtrrrprr new_statesr)rrrrrrs) rc  Cs|s$|dkr$tj|dd}d\} } n|r,dnd\} } tj|| d}tj|ddd} | tj|ddd7} tt|d }td r| d| d | d <| d<| d | d| d<| d <|d|d |d <|d<|d |d|d<|d <t| |t d gdd} |dk rt ||}|dk r|r:tj ||| | d}t j||d | dd||d\} }}}}|rtj | || | d} tj| | gd} n4|rtj|d gd}t j||d | ddd\} }}}| d }|s|dkrtj| dd dgd} tj|| d}|dk r|}|| |ttfS)z>GRU with CuDNN implementation which is only available for GPU.N)rrr)perm)rr)rr)rrrZ is_cuda_buildrT)weightsbiasesshapetranspose_weights)seq_axis batch_axisr )inputinput_hinput_cparams is_trainingrnn_moderr!)rrrrrrr)r transpose expand_dimsrr flattenrget_build_info_canonical_to_paramsrconstantcalculate_sequence_by_maskreverse_sequence_v2r CudnnRNNV3reverseCudnnRNNsqueezer} _RUNTIME_GPU)rrrrrrrr!r"rrrrrrrr#rrrrrqsb        rc  s|||||||||| d ddtr`ttfddtfddifdd\} } } } nTdtt}||d }t|tt |}t|t|}|f\} } } } t |f| | | | fS) awCall the GRU with optimized backend kernel selection. Under the hood, this function will create two TF function, one with the most generic kernel and can run on all device condition, and the second one with CuDNN specific kernel, which can only run on GPU. The first function will be called with normal_lstm_params, while the second function is not called, but only registered in the graph. The Grappler will do the proper graph rewrite and swap the optimized TF function based on the device placement. Args: inputs: Input tensor of GRU layer. init_h: Initial state tensor for the cell output. kernel: Weights for cell kernel. recurrent_kernel: Weights for cell recurrent kernel. bias: Weights for cell kernel bias and recurrent bias. Only recurrent bias is used in this case. mask: Boolean tensor for mask out the steps within sequence. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: Boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. zero_output_for_mask: Boolean, whether to output zero for masked timestep. Returns: List of output tensors, same as standard_gru. ) rrrrrrrr!r"rrtc srdkr"td Sf dd}  f dd} tjt| | dS)z.gpu_gru_with_fallback..cudnn_gru_fnc st d S)N) rrrrrrrr!r"rrt)rr) rr"rrrrrrrr!rtrrstandard_gru_fnszRgru_with_backend_selection..gpu_gru_with_fallback..standard_gru_fn)true_fnfalse_fn)rrcondr) rrrrrrrr!r"rrtrrr) rr"rrrrrrrr!rtrgpu_gru_with_fallbacks"  z9gru_with_backend_selection..gpu_gru_with_fallbackcs tfS)N)rr)rrr,z,gru_with_backend_selection..cs fS)Nrr)rrrrr-rcs tfS)N)rr)rrrr.rZgru_)r!r") rrexecute_fn_for_device_CPU_DEVICE_NAMErr*r+r,_generate_defun_backendr_function_register)rrrrrrrr!r"rrtrrrrapi_namesupportive_attributeZdefun_standard_gruZ defun_gpu_grur)rrrr.s8&.  r.zkeras.layers.LSTMCellcs"eZdZdZd fd d ZZS) LSTMCella Cell class for the LSTM layer. See [the Keras RNN API guide](https://www.tensorflow.org/guide/keras/rnn) for details about the usage of RNN API. This class processes one step within the whole time sequence input, whereas `tf.keras.layer.LSTM` processes the whole sequence. For example: >>> inputs = tf.random.normal([32, 10, 8]) >>> rnn = tf.keras.layers.RNN(tf.keras.layers.LSTMCell(4)) >>> output = rnn(inputs) >>> print(output.shape) (32, 4) >>> rnn = tf.keras.layers.RNN( ... tf.keras.layers.LSTMCell(4), ... return_sequences=True, ... return_state=True) >>> whole_seq_output, final_memory_state, final_carry_state = rnn(inputs) >>> print(whole_seq_output.shape) (32, 10, 4) >>> print(final_memory_state.shape) (32, 4) >>> print(final_carry_state.shape) (32, 4) Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean, (default `True`), whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `glorot_uniform`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `orthogonal`. bias_initializer: Initializer for the bias vector. Default: `zeros`. unit_forget_bias: Boolean (default `True`). If True, add 1 to the bias of the forget gate at initialization. Setting it to true will also force `bias_initializer="zeros"`. This is recommended in [Jozefowicz et al.](http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf) kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. Call arguments: inputs: A 2D tensor, with shape of `[batch, feature]`. states: List of 2 tensors that corresponding to the cell's units. Both of them have shape `[batch, units]`, the first tensor is the memory state from previous time step, the second tensor is the carry state from previous time step. For timestep 0, the initial state provided by user will be feed to cell. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. Only relevant when `dropout` or `recurrent_dropout` is used. r=r>Tr?r@rANc sFtt|j|f|||||||| | | | | ||||ddd|dS)NrCr)rDrErFrGrHrIunit_forget_biasrJrKrLrMrNrOrPrQrC)rSrr3rT)r1rUrDrErFrGrHrIrrJrKrLrMrNrOrPrQrV)rWrrr3s& zLSTMCell.__init__)r=r>Tr?r@rATNNNNNNrr)r8r9r:r;r3rXrr)rWrrHs Krzkeras.layers.LSTMcs,eZdZdZdfd d Zdd dZZS)LSTMaLong Short-Term Memory layer - Hochreiter 1997. See [the Keras RNN API guide](https://www.tensorflow.org/guide/keras/rnn) for details about the usage of RNN API. Based on available runtime hardware and constraints, this layer will choose different implementations (cuDNN-based or pure-TensorFlow) to maximize the performance. If a GPU is available and all the arguments to the layer meet the requirement of the CuDNN kernel (see below for details), the layer will use a fast cuDNN implementation. The requirements to use the cuDNN implementation are: 1. `activation` == `tanh` 2. `recurrent_activation` == `sigmoid` 3. `recurrent_dropout` == 0 4. `unroll` is `False` 5. `use_bias` is `True` 6. Inputs, if use masking, are strictly right-padded. 7. Eager execution is enabled in the outermost context. For example: >>> inputs = tf.random.normal([32, 10, 8]) >>> lstm = tf.keras.layers.LSTM(4) >>> output = lstm(inputs) >>> print(output.shape) (32, 4) >>> lstm = tf.keras.layers.LSTM(4, return_sequences=True, return_state=True) >>> whole_seq_output, final_memory_state, final_carry_state = lstm(inputs) >>> print(whole_seq_output.shape) (32, 10, 4) >>> print(final_memory_state.shape) (32, 4) >>> print(final_carry_state.shape) (32, 4) Args: units: Positive integer, dimensionality of the output space. activation: Activation function to use. Default: hyperbolic tangent (`tanh`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). recurrent_activation: Activation function to use for the recurrent step. Default: sigmoid (`sigmoid`). If you pass `None`, no activation is applied (ie. "linear" activation: `a(x) = x`). use_bias: Boolean (default `True`), whether the layer uses a bias vector. kernel_initializer: Initializer for the `kernel` weights matrix, used for the linear transformation of the inputs. Default: `glorot_uniform`. recurrent_initializer: Initializer for the `recurrent_kernel` weights matrix, used for the linear transformation of the recurrent state. Default: `orthogonal`. bias_initializer: Initializer for the bias vector. Default: `zeros`. unit_forget_bias: Boolean (default `True`). If True, add 1 to the bias of the forget gate at initialization. Setting it to true will also force `bias_initializer="zeros"`. This is recommended in [Jozefowicz et al.](http://www.jmlr.org/proceedings/papers/v37/jozefowicz15.pdf). kernel_regularizer: Regularizer function applied to the `kernel` weights matrix. Default: `None`. recurrent_regularizer: Regularizer function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_regularizer: Regularizer function applied to the bias vector. Default: `None`. activity_regularizer: Regularizer function applied to the output of the layer (its "activation"). Default: `None`. kernel_constraint: Constraint function applied to the `kernel` weights matrix. Default: `None`. recurrent_constraint: Constraint function applied to the `recurrent_kernel` weights matrix. Default: `None`. bias_constraint: Constraint function applied to the bias vector. Default: `None`. dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the inputs. Default: 0. recurrent_dropout: Float between 0 and 1. Fraction of the units to drop for the linear transformation of the recurrent state. Default: 0. return_sequences: Boolean. Whether to return the last output. in the output sequence, or the full sequence. Default: `False`. return_state: Boolean. Whether to return the last state in addition to the output. Default: `False`. go_backwards: Boolean (default `False`). If True, process the input sequence backwards and return the reversed sequence. stateful: Boolean (default `False`). If True, the last state for each sample at index i in a batch will be used as initial state for the sample of index i in the following batch. time_major: The shape format of the `inputs` and `outputs` tensors. If True, the inputs and outputs will be in shape `[timesteps, batch, feature]`, whereas in the False case, it will be `[batch, timesteps, feature]`. Using `time_major = True` is a bit more efficient because it avoids transposes at the beginning and end of the RNN calculation. However, most TensorFlow data is batch-major, so by default this function accepts input and emits output in batch-major form. unroll: Boolean (default `False`). If True, the network will be unrolled, else a symbolic loop will be used. Unrolling can speed-up a RNN, although it tends to be more memory-intensive. Unrolling is only suitable for short sequences. Call arguments: inputs: A 3D tensor with shape `[batch, timesteps, feature]`. mask: Binary tensor of shape `[batch, timesteps]` indicating whether a given timestep should be masked (optional, defaults to `None`). An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. training: Python boolean indicating whether the layer should behave in training mode or in inference mode. This argument is passed to the cell when calling it. This is only relevant if `dropout` or `recurrent_dropout` is used (optional, defaults to `None`). initial_state: List of initial state tensors to be passed to the first call of the cell (optional, defaults to `None` which causes creation of zero-filled initial state tensors). r=r>Tr?r@rANFc s|dd|_tt|j|f|||||||| | | | | |||||dd||||||d|dd|j|jfD|_|jtj t j fko|j tj t j fko|dko| o|ot |_td r|jrtt|jntt|jtrt||d |_dS) Nr[FrCr)rDrErFrGrHrIrrJrKrLr\rMrNrOrPrQrCr]r^r"r_r!r`cSsg|]}td|fdqS)N)r)r ).0dimrrr gsz!LSTM.__init__..rrr)rTr[rSrr3rUZ state_specrDr r=rrEr>r rbrcrrdrerfrgrhrirjrrrk)r1rUrDrErFrGrHrIrrJrKrLr\rMrNrOrPrQr]r^r"r_r!r`rV)rWrrr3.sL    z LSTM.__init__c st|\}}|dk }||||d\}}}t|trH|d}t|}jr`|dn|d} |srjsd|i j fdd} tj | ||dj |j |dk r|n| jjd \} } } tt}nj||dd}|dk r||d}trr|t|dt|dtj jtj jtj j|jj |jd }jjf|\} } }}}n|t|dt|dtj jtj jtj j|jj |d }|}|d jitrHt}|tks|dkot !d o|dkpt"|j}|r2t#f|\} } }}}nt$f|\} } }}}nt%f|\} } }}}||g} j&rd dt'j(| D})|j*rtj+|| |j d}n| }j,r|gt| Sj-r||fS|SdS)Nrrrlcsj||fS)N)rm)rr)rVr1rrrpszLSTM.call..step)rqr"rrr`rsr!rtr)r) rrinit_crrrrrr!r"rrt) rrrrrrrrr!r"rrtrcSsg|]\}}t||qSr)rr)rZ self_statestaterrrrszLSTM.call..)r").r rurvrwrxryrzr!rcr{rmr|r"r`rtr}r~rrrrrrrrkr0rrrrrrrrdrgpu_lstm standard_lstmr-r_ziprrr]rr^r[)r1rrrrlrrrr#rrrprrrrrZ lstm_kwargsrnew_cZgpu_lstm_kwargsZnormal_lstm_kwargsrrrrr)rVr1rrys                         z LSTM.call)r=r>Tr?r@rATNNNNNNNrrFFFFFF)NNN)r8r9r:r;r3rrXrr)rWrrs0p4rFcsDfddfdd|D}fdd|D}tj||ddS)aUtility function convert variable to CuDNN compatible parameter. Note that Keras weights for kernels are different from the CuDNN format. Eg.: ``` Keras CuDNN [[0, 1, 2], <---> [[0, 2, 4], [3, 4, 5]] [1, 3, 5]] ``` If the input weights need to be in a unified format, then set `transpose_weights=True` to convert the weights. Args: weights: list of weights for the individual kernels and recurrent kernels. biases: list of biases for individual gate. shape: the shape for the converted variables that will be feed to CuDNN. transpose_weights: boolean, whether to transpose the weights. Returns: The converted weights that can be feed to CuDNN ops as param. csrt|S|S)N)rr)w)rrrconvert"sz%_canonical_to_params..convertcsg|]}t|qSr)rreshape)rx)rrrrr%sz(_canonical_to_params..csg|]}t|qSr)rr)rr)rrrr&sr)r)rconcat)rrrrr)rrrrr s rc  s|t|} |r| dn| d} fdd} tj| |||gdd|||| dk rR| n| | d \}}}|||d|dttfS)aLSTM with standard kernel implementation. This implementation can be run on all types for hardware. This implementation lifts out all the layer weights and make them function parameters. It has same number of tensor input params as the CuDNN counterpart. The RNN step logic has been simplified, eg dropout and mask is removed since CuDNN implementation does not support that. Note that the first half of the bias tensor should be ignored by this impl. The CuDNN impl need an extra set of input gate bias. In order to make the both function take same shape of parameter, that extra set of bias is also feed here. Args: inputs: input tensor of LSTM layer. init_h: initial state tensor for the cell output. init_c: initial state tensor for the cell hidden state. kernel: weights for cell kernel. recurrent_kernel: weights for cell recurrent kernel. bias: weights for cell kernel bias and recurrent bias. Only recurrent bias is used in this case. mask: Boolean tensor for mask out the steps within sequence. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. zero_output_for_mask: Boolean, whether to output zero for masked timestep. Returns: last_output: output tensor for the last timestep, which has shape [batch, units]. outputs: output tensor for all timesteps, which has shape [batch, time, units]. state_0: the cell output, which has same shape as init_h. state_1: the cell hidden state, which has same shape as init_c. runtime: constant string tensor which indicate real runtime hardware. This value is for testing purpose and should be used by user. rrcs|d}|d}t|}|t|7}t|}tj|ddd\}}}}t|} t|} | || t|} t|} | t| } | | | gfS)z5Step function that will be used by Keras RNN backend.rrr)r)r rrrrrr>r=)rnrorZc_tm1rZz0Zz1Zz2Zz3ifcor)rrrrrrp]s     zstandard_lstm..stepNF)rqr`r!rrr"rsrt)r rzr|r}r)rrrrrrrrr!r"rrtrrrprrrr)rrrrr*s0 rc  s|s$|dkr$tj|dd}d\} } n|r,dnd\} } tj|| d}tj|| d}tj|dddtj|ddd7tt||fd td rʇfd d d Dtjdd dfdd d Dttdt dgdd} |dk rt ||} | dk rl|rtj || | | d}t j|||| dd| |d\} }}}}|rtj | | | | d} tj| | gd} n4|rtj|d gd}t j|||| ddd\} }}}| d}|s|dkrtj| dd dgd} tj|| d}tj|| d}|dk r|}|| ||ttfS)aLSTM with either CuDNN or ROCm implementation which is only available for GPU. Note that currently only right padded data is supported, or the result will be polluted by the unmasked data which should be filtered. Args: inputs: Input tensor of LSTM layer. init_h: Initial state tensor for the cell output. init_c: Initial state tensor for the cell hidden state. kernel: Weights for cell kernel. recurrent_kernel: Weights for cell recurrent kernel. bias: Weights for cell kernel bias and recurrent bias. Only recurrent bias is used in this case. mask: Boolean tensor for mask out the steps within sequence. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: Boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. Returns: last_output: Output tensor for the last timestep, which has shape [batch, units]. outputs: Output tensor for all timesteps, which has shape [batch, time, units]. state_0: The cell output, which has same shape as init_h. state_1: The cell hidden state, which has same shape as init_c. runtime: Constant string tensor which indicate real runtime hardware. This value is for testing purpose and should not be used by user. N)rrr)r)rr)rr)rrrrZ is_rocm_buildcsg|] }|qSrr)rr)rrrrszgpu_lstm..)rrrrrrcsg|] }|qSrr)rr) full_biasrrrsrT)rrrr)rrr)rrrrrrrr!)rrrrrrr)rrrrrZ zeros_likerrrrrrrrrrrrr}r)rrrrrrrrr!r"rrrrrrrr#rr)rrrrsd%        rc  s|||||||||| | d ddtrdttfddtfddifdd\} } } }}nVdtt}||d }t|tt |}t|t|}|f\} } } }}t |f| | | ||fS) aCall the LSTM with optimized backend kernel selection. Under the hood, this function will create two TF function, one with the most generic kernel and can run on all device condition, and the second one with CuDNN specific kernel, which can only run on GPU. The first function will be called with normal_lstm_params, while the second function is not called, but only registered in the graph. The Grappler will do the proper graph rewrite and swap the optimized TF function based on the device placement. Args: inputs: Input tensor of LSTM layer. init_h: Initial state tensor for the cell output. init_c: Initial state tensor for the cell hidden state. kernel: Weights for cell kernel. recurrent_kernel: Weights for cell recurrent kernel. bias: Weights for cell kernel bias and recurrent bias. Only recurrent bias is used in this case. mask: Boolean tensor for mask out the steps within sequence. An individual `True` entry indicates that the corresponding timestep should be utilized, while a `False` entry indicates that the corresponding timestep should be ignored. time_major: Boolean, whether the inputs are in the format of [time, batch, feature] or [batch, time, feature]. go_backwards: Boolean (default False). If True, process the input sequence backwards and return the reversed sequence. sequence_lengths: The lengths of all sequences coming from a variable length input, such as ragged tensors. If the input has a fixed timestep size, this should be None. zero_output_for_mask: Boolean, whether to output zero for masked timestep. Returns: List of output tensors, same as standard_lstm. ) rrrrrrrrr!r"rrtc sxdkr$t d S f dd}  f dd} tjt | | dS)z.gpu_lstm_with_fallback..cudnn_lstm_fnc st  d S)N) rrrrrrrrr!r"rrt)rr) rr"rrrrrrrrr!rtrrstardard_lstm_fnOszUlstm_with_backend_selection..gpu_lstm_with_fallback..stardard_lstm_fn)rr)rrrr) rrrrrrrrr!r"rrtrrr) rr"rrrrrrrrr!rtrgpu_lstm_with_fallback1s$ z;lstm_with_backend_selection..gpu_lstm_with_fallbackcs tfS)N)rr)rrrrgrz-lstm_with_backend_selection..cs fS)Nrr)rrrrrhrcs tfS)N)rr)rrrrirZlstm_)r!r") rrrrrr*r+r,rrr)rrrrrrrrr!r"rrtrrrrrrrZdefun_standard_lstmZdefun_gpu_lstmr)rrrr-s:(1  r-cCsFt|d}tjt|tjdd}tj||d}tt ||S)aACheck the mask tensor and see if it right padded. For CuDNN kernel, it uses the sequence length param to skip the tailing timestep. If the data is left padded, or not a strict right padding (has masked value in the middle of the sequence), then CuDNN kernel won't be work properly in those cases. Left padded data: [[False, False, True, True, True]]. Right padded data: [[True, True, True, False, False]]. Mixture of mask/unmasked data: [[True, False, True, False, False]]. Note that for the mixed data example above, the actually data RNN should see are those 2 Trues (index 0 and 2), the index 1 False should be ignored and not pollute the internal states. Args: mask: the Boolean tensor with shape [batch, timestep] Returns: boolean scalar tensor, whether the mask is strictly right padded. r)r)maxlen) rrr reduce_sumcastrint32Z sequence_mask reduce_allequal)rrZmax_seq_lengthZ count_of_trueZright_padded_maskrrris_sequence_right_paddeds  rcCsttjt|ddS)Nr)r)rZ reduce_anyr logical_not)rrrrrhas_fully_masked_sequencesrcCs(|rt|}tt|tt|S)N)rrr logical_andrrr)rrr!rrrrs  rcCs$|rdnd}tjt|tj|dS)a/Calculate the sequence length tensor (1-D) based on the masking tensor. The masking tensor is a 2D boolean tensor with shape [batch, timestep]. For any timestep that should be masked, the corresponding field will be False. Consider the following example: a = [[True, True, False, False], [True, True, True, False]] It is a (2, 4) tensor, and the corresponding sequence length result should be 1D tensor with value [2, 3]. Note that the masking tensor must be right padded that could be checked by, e.g., `is_sequence_right_padded()`. Args: mask: Boolean tensor with shape [batch, timestep] or [timestep, batch] if time_major=True. time_major: Boolean, which indicates whether the mask is time major or batch major. Returns: sequence_length: 1D int32 tensor. rr)r)rrrrr)rrr!Ztimestep_indexrrrrs rcCs&t|t|i}||tj||ddS)NF)funcr$r%)r)_FUNCTION_DEVICE_ATTRIBUTErrr/)Zunique_api_nameZpreferred_devicerr2Zfunction_attributesrrrrs  rcCs t}|dkrdStj|jS)zAParse the current context and return the device type, eg CPU/GPU.N)rrZ DeviceSpecZ from_stringr)Zcurrent_devicerrrrsrc Cs(tdtj|tjddSQRXdS)Nz/cpu:0r)Zdtyperh)r rrrrZfloat32)Z runtime_namerrrr}s r}cCst|tjr|S|S)z/Read the value of a variable if it is variable.)rxrVariableZ read_value)vrrrrs rcOs |j||}|||S)aRegister a specialization of a `Function` into the graph. This won't actually call the function with the inputs, and only put the function definition into graph. Register function with different input param will result into multiple version of functions registered in graph. Args: func: the `Function` instance that generated by a @defun *args: input arguments for the Python function. **kwargs: input keyword arguments for the Python function. Returns: a `ConcreteFunction` object specialized to inputs and execution context. Raises: ValueError: When the input function is not a defun wrapped python function. )Zget_concrete_functionZ add_to_graphZadd_gradient_functions_to_graph)rargsrVZ concrete_funcrrrrs r)F)Cr;r+Ztensorflow.python.eagerrrZtensorflow.python.eager.contextrZtensorflow.python.frameworkrrrrr Ztensorflow.python.kerasr r Z)tensorflow.python.keras.engine.input_specr Ztensorflow.python.keras.layersr Ztensorflow.python.opsrrrrrrrZtensorflow.python.platformrrreZ tensorflow.python.util.tf_exportrr)rrrr~rrrgrjrobjectrr<ZDropoutRNNCellMixinrYrrr.rrrrrr-rrrrrrr}rrrrrrs                      ! oETV sP U}