This class processes one step within the whole time sequence input, whereas
`layer_simple_rnn()`

processes the whole sequence.

## Usage

```
rnn_cell_simple(
units,
activation = "tanh",
use_bias = TRUE,
kernel_initializer = "glorot_uniform",
recurrent_initializer = "orthogonal",
bias_initializer = "zeros",
kernel_regularizer = NULL,
recurrent_regularizer = NULL,
bias_regularizer = NULL,
kernel_constraint = NULL,
recurrent_constraint = NULL,
bias_constraint = NULL,
dropout = 0,
recurrent_dropout = 0,
seed = NULL,
...
)
```

## Arguments

- units
Positive integer, dimensionality of the output space.

- activation
Activation function to use. Default: hyperbolic tangent (

`tanh`

). If you pass`NULL`

, no activation is applied (ie. "linear" activation:`a(x) = x`

).- use_bias
Boolean, (default

`TRUE`

), whether the layer should use 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:`NULL`

.- recurrent_regularizer
Regularizer function applied to the

`recurrent_kernel`

weights matrix. Default:`NULL`

.- bias_regularizer
Regularizer function applied to the bias vector. Default:

`NULL`

.- kernel_constraint
Constraint function applied to the

`kernel`

weights matrix. Default:`NULL`

.- recurrent_constraint
Constraint function applied to the

`recurrent_kernel`

weights matrix. Default:`NULL`

.- bias_constraint
Constraint function applied to the bias vector. Default:

`NULL`

.- 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.

- seed
Random seed for dropout.

- ...
For forward/backward compatability.

## Value

A `Layer`

instance, which is intended to be used with `layer_rnn()`

.

## Call Arguments

`sequence`

: A 2D tensor, with shape`(batch, features)`

.`states`

: A 2D tensor with shape`(batch, units)`

, which is the state from the previous time step.`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.

## Examples

```
inputs <- random_uniform(c(32, 10, 8))
rnn <- layer_rnn(cell = rnn_cell_simple(units = 4))
output <- rnn(inputs) # The output has shape `(32, 4)`.
rnn <- layer_rnn(
cell = rnn_cell_simple(units = 4),
return_sequences=TRUE,
return_state=TRUE
)
# whole_sequence_output has shape `(32, 10, 4)`.
# final_state has shape `(32, 4)`.
c(whole_sequence_output, final_state) %<-% rnn(inputs)
```

## See also

Other rnn cells: `layer_rnn()`

`rnn_cell_gru()`

`rnn_cell_lstm()`

Other simple rnn layers: `layer_simple_rnn()`

Other rnn layers: `layer_bidirectional()`

`layer_conv_lstm_1d()`

`layer_conv_lstm_2d()`

`layer_conv_lstm_3d()`

`layer_gru()`

`layer_lstm()`

`layer_rnn()`

`layer_simple_rnn()`

`layer_time_distributed()`

`rnn_cell_gru()`

`rnn_cell_lstm()`

`rnn_cells_stack()`

Other layers: `Layer()`

`layer_activation()`

`layer_activation_elu()`

`layer_activation_leaky_relu()`

`layer_activation_parametric_relu()`

`layer_activation_relu()`

`layer_activation_softmax()`

`layer_activity_regularization()`

`layer_add()`

`layer_additive_attention()`

`layer_alpha_dropout()`

`layer_attention()`

`layer_average()`

`layer_average_pooling_1d()`

`layer_average_pooling_2d()`

`layer_average_pooling_3d()`

`layer_batch_normalization()`

`layer_bidirectional()`

`layer_category_encoding()`

`layer_center_crop()`

`layer_concatenate()`

`layer_conv_1d()`

`layer_conv_1d_transpose()`

`layer_conv_2d()`

`layer_conv_2d_transpose()`

`layer_conv_3d()`

`layer_conv_3d_transpose()`

`layer_conv_lstm_1d()`

`layer_conv_lstm_2d()`

`layer_conv_lstm_3d()`

`layer_cropping_1d()`

`layer_cropping_2d()`

`layer_cropping_3d()`

`layer_dense()`

`layer_depthwise_conv_1d()`

`layer_depthwise_conv_2d()`

`layer_discretization()`

`layer_dot()`

`layer_dropout()`

`layer_einsum_dense()`

`layer_embedding()`

`layer_feature_space()`

`layer_flatten()`

`layer_gaussian_dropout()`

`layer_gaussian_noise()`

`layer_global_average_pooling_1d()`

`layer_global_average_pooling_2d()`

`layer_global_average_pooling_3d()`

`layer_global_max_pooling_1d()`

`layer_global_max_pooling_2d()`

`layer_global_max_pooling_3d()`

`layer_group_normalization()`

`layer_group_query_attention()`

`layer_gru()`

`layer_hashed_crossing()`

`layer_hashing()`

`layer_identity()`

`layer_integer_lookup()`

`layer_lambda()`

`layer_layer_normalization()`

`layer_lstm()`

`layer_masking()`

`layer_max_pooling_1d()`

`layer_max_pooling_2d()`

`layer_max_pooling_3d()`

`layer_maximum()`

`layer_minimum()`

`layer_multi_head_attention()`

`layer_multiply()`

`layer_normalization()`

`layer_permute()`

`layer_random_brightness()`

`layer_random_contrast()`

`layer_random_crop()`

`layer_random_flip()`

`layer_random_rotation()`

`layer_random_translation()`

`layer_random_zoom()`

`layer_repeat_vector()`

`layer_rescaling()`

`layer_reshape()`

`layer_resizing()`

`layer_rnn()`

`layer_separable_conv_1d()`

`layer_separable_conv_2d()`

`layer_simple_rnn()`

`layer_spatial_dropout_1d()`

`layer_spatial_dropout_2d()`

`layer_spatial_dropout_3d()`

`layer_spectral_normalization()`

`layer_string_lookup()`

`layer_subtract()`

`layer_text_vectorization()`

`layer_tfsm()`

`layer_time_distributed()`

`layer_torch_module_wrapper()`

`layer_unit_normalization()`

`layer_upsampling_1d()`

`layer_upsampling_2d()`

`layer_upsampling_3d()`

`layer_zero_padding_1d()`

`layer_zero_padding_2d()`

`layer_zero_padding_3d()`

`rnn_cell_gru()`

`rnn_cell_lstm()`

`rnn_cells_stack()`