{ }
View source on GitHub |
Gated Recurrent Unit - Cho et al. 2014.
Inherits From: RNN
, Layer
, Operation
tf.keras.layers.GRU(
units,
activation='tanh',
recurrent_activation='sigmoid',
use_bias=True,
kernel_initializer='glorot_uniform',
recurrent_initializer='orthogonal',
bias_initializer='zeros',
kernel_regularizer=None,
recurrent_regularizer=None,
bias_regularizer=None,
activity_regularizer=None,
kernel_constraint=None,
recurrent_constraint=None,
bias_constraint=None,
dropout=0.0,
recurrent_dropout=0.0,
seed=None,
return_sequences=False,
return_state=False,
go_backwards=False,
stateful=False,
unroll=False,
reset_after=True,
use_cudnn='auto',
**kwargs
)
Used in the notebooks
Used in the guide | Used in the tutorials |
---|---|
Based on available runtime hardware and constraints, this layer will choose different implementations (cuDNN-based or backend-native) 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 when using the TensorFlow backend.
The requirements to use the cuDNN implementation are:
activation
==tanh
recurrent_activation
==sigmoid
dropout
== 0 andrecurrent_dropout
== 0unroll
isFalse
use_bias
isTrue
reset_after
isTrue
- Inputs, if use masking, are strictly right-padded.
- Eager execution is enabled in the outermost context.
There are two variants of the GRU implementation. The default one is based on v3 and has reset gate applied to hidden state before matrix multiplication. The other one is based on original 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 = np.random.random((32, 10, 8))
gru = keras.layers.GRU(4)
output = gru(inputs)
output.shape
(32, 4)
gru = keras.layers.GRU(4, return_sequences=True, return_state=True)
whole_sequence_output, final_state = gru(inputs)
whole_sequence_output.shape
(32, 10, 4)
final_state.shape
(32, 4)
Methods
from_config
@classmethod
from_config( config )
Creates a layer from its config.
This method is the reverse of get_config
,
capable of instantiating the same layer from the config
dictionary. It does not handle layer connectivity
(handled by Network), nor weights (handled by set_weights
).
Args | |
---|---|
config
|
A Python dictionary, typically the output of get_config. |
Returns | |
---|---|
A layer instance. |
get_initial_state
get_initial_state(
batch_size
)
inner_loop
inner_loop(
sequences, initial_state, mask, training=False
)
reset_state
reset_state()
reset_states
reset_states()
symbolic_call
symbolic_call(
*args, **kwargs
)