资料来自keras源码。

关于units的源码解释如下：

units: Positive integer, dimensionality of the output space.

self.output_size = self.units

def output_size(self):

"""Integer or TensorShape: size of outputs produced by this cell."""

raise NotImplementedError('Abstract method')

outputsize的解释：

- A `state_size` attribute. This can be a single integer

(single state) in which case it is the size of the recurrent

state. This can also be a list/tuple of integers (one size per

state).

The `state_size` can also be TensorShape or tuple/list of

TensorShape, to represent high dimension state.

- A `output_size` attribute. This can be a single integer or a

TensorShape, which represent the shape of the output. For backward

compatible reason, if this attribute is not available for the

cell, the value will be inferred by the first element of the

`state_size`.

An RNN cell, in the most abstract setting, is anything that has

a state and performs some operation that takes a matrix of inputs.

This operation results in an output matrix with `self.output_size` columns.

If `self.state_size` is an integer, this operation also results in a new

state matrix with `self.state_size` columns. If `self.state_size` is a

(possibly nested tuple of) TensorShape object(s), then it should return a

matching structure of Tensors having shape `[batch_size].concatenate(s)`

for each `s` in `self.batch_size`.

"""An "LSTM with 50 neurons" or an "LSTM with 50 units" basically means that the dimension of the output vector, h, is 50.

关于timesteps的源码解释如下：

input_shape = K.int_shape(inputs)

timesteps = input_shape[0] if time_major else input_shape[1]

input shape解释：

Input shape:

N-D tensor with shape `(batch_size, timesteps, ...)` or

`(timesteps, batch_size, ...)` when time_major is True.

output shape解释：

Output shape:

- If `return_state`: a list of tensors. The first tensor is

the output. The remaining tensors are the last states,

each with shape `(batch_size, state_size)`, where `state_size` could

be a high dimension tensor shape.

- If `return_sequences`: N-D tensor with shape

`(batch_size, timesteps, output_size)`, where `output_size` could

be a high dimension tensor shape, or

`(timesteps, batch_size, output_size)` when `time_major` is True.

- Else, N-D tensor with shape `(batch_size, output_size)`, where

`output_size` could be a high dimension tensor shape.

K解释：

"""Turn a nD tensor into a 2D tensor with same 0th dimension.

In other words, it flattens each data samples of a batch.

Arguments:

x: A tensor or variable.

Returns:

A tensor.

Examples:

Flattening a 3D tensor to 2D by collapsing the last dimension.

```python

>>> from tensorflow.keras import backend as K

>>> x_batch = K.ones(shape=(2, 3, 4, 5))

>>> x_batch_flatten = K.batch_flatten(x_batch)

>>> K.int_shape(x_batch_flatten)

(2, 60)

```

"""

time_major解释：

time_major: The shape format of the `inputs` and `outputs` tensors.

If True, the inputs and outputs will be in shape

`(timesteps, batch, ...)`, whereas in the False case, it will be

`(batch, timesteps, ...)`. 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.The timestep in essence is the number of units (seconds/minutes/hours/days/frames in a video etc.) which is used to predict the future step(s).