Class TimeDistributed
Inherits From: Wrapper
Defined in tensorflow/python/keras/layers/wrappers.py
.
This wrapper allows to apply a layer to every temporal slice of an input.
The input should be at least 3D, and the dimension of index one will be considered to be the temporal dimension.
Consider a batch of 32 samples,
where each sample is a sequence of 10 vectors of 16 dimensions.
The batch input shape of the layer is then (32, 10, 16)
,
and the input_shape
, not including the samples dimension, is (10, 16)
.
You can then use TimeDistributed
to apply a Dense
layer
to each of the 10 timesteps, independently:
# as the first layer in a model
model = Sequential()
model.add(TimeDistributed(Dense(8), input_shape=(10, 16)))
# now model.output_shape == (None, 10, 8)
The output will then have shape (32, 10, 8)
.
In subsequent layers, there is no need for the input_shape
:
model.add(TimeDistributed(Dense(32)))
# now model.output_shape == (None, 10, 32)
The output will then have shape (32, 10, 32)
.
TimeDistributed
can be used with arbitrary layers, not just Dense
,
for instance with a Conv2D
layer:
model = Sequential()
model.add(TimeDistributed(Conv2D(64, (3, 3)),
input_shape=(10, 299, 299, 3)))
Arguments:
layer
: a layer instance.
Raises:
ValueError
: If not initialized with aLayer
instance.
__init__
__init__(
layer,
**kwargs
)
Properties
activity_regularizer
Optional regularizer function for the output of this layer.
dtype
input
Retrieves the input tensor(s) of a layer.
Only applicable if the layer has exactly one input, i.e. if it is connected to one incoming layer.
Returns:
Input tensor or list of input tensors.
Raises:
AttributeError
: if the layer is connected to more than one incoming layers.
Raises:
RuntimeError
: If called in Eager mode.AttributeError
: If no inbound nodes are found.
input_mask
Retrieves the input mask tensor(s) of a layer.
Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer.
Returns:
Input mask tensor (potentially None) or list of input mask tensors.
Raises:
AttributeError
: if the layer is connected to more than one incoming layers.
input_shape
Retrieves the input shape(s) of a layer.
Only applicable if the layer has exactly one input, i.e. if it is connected to one incoming layer, or if all inputs have the same shape.
Returns:
Input shape, as an integer shape tuple (or list of shape tuples, one tuple per input tensor).
Raises:
AttributeError
: if the layer has no defined input_shape.RuntimeError
: if called in Eager mode.
losses
Losses which are associated with this Layer
.
Variable regularization tensors are created when this property is accessed,
so it is eager safe: accessing losses
under a tf.GradientTape
will
propagate gradients back to the corresponding variables.
Returns:
A list of tensors.
name
non_trainable_variables
non_trainable_weights
output
Retrieves the output tensor(s) of a layer.
Only applicable if the layer has exactly one output, i.e. if it is connected to one incoming layer.
Returns:
Output tensor or list of output tensors.
Raises:
AttributeError
: if the layer is connected to more than one incoming layers.RuntimeError
: if called in Eager mode.
output_mask
Retrieves the output mask tensor(s) of a layer.
Only applicable if the layer has exactly one inbound node, i.e. if it is connected to one incoming layer.
Returns:
Output mask tensor (potentially None) or list of output mask tensors.
Raises:
AttributeError
: if the layer is connected to more than one incoming layers.
output_shape
Retrieves the output shape(s) of a layer.
Only applicable if the layer has one output, or if all outputs have the same shape.
Returns:
Output shape, as an integer shape tuple (or list of shape tuples, one tuple per output tensor).
Raises:
AttributeError
: if the layer has no defined output shape.RuntimeError
: if called in Eager mode.
trainable
trainable_variables
trainable_weights
updates
variables
Returns the list of all layer variables/weights.
Alias of self.weights
.
Returns:
A list of variables.
weights
Returns the list of all layer variables/weights.
Returns:
A list of variables.
Methods
tf.keras.layers.TimeDistributed.__call__
__call__(
inputs,
*args,
**kwargs
)
Wraps call
, applying pre- and post-processing steps.
Arguments:
inputs
: input tensor(s).*args
: additional positional arguments to be passed toself.call
.**kwargs
: additional keyword arguments to be passed toself.call
.
Returns:
Output tensor(s).
Raises:
ValueError
: if the layer'scall
method returns None (an invalid value).
tf.keras.layers.TimeDistributed.__setattr__
__setattr__(
name,
value
)
Implement setattr(self, name, value).
tf.keras.layers.TimeDistributed.apply
apply(
inputs,
*args,
**kwargs
)
Apply the layer on a input.
This is an alias of self.__call__
.
Arguments:
inputs
: Input tensor(s).*args
: additional positional arguments to be passed toself.call
.**kwargs
: additional keyword arguments to be passed toself.call
.
Returns:
Output tensor(s).
tf.keras.layers.TimeDistributed.build
build(input_shape)
Creates the variables of the layer (optional, for subclass implementers).
This is a method that implementers of subclasses of Layer
or Model
can override if they need a state-creation step in-between
layer instantiation and layer call.
This is typically used to create the weights of Layer
subclasses.
Arguments:
input_shape
: Instance ofTensorShape
, or list of instances ofTensorShape
if the layer expects a list of inputs (one instance per input).
tf.keras.layers.TimeDistributed.compute_mask
compute_mask(
inputs,
mask=None
)
Computes an output mask tensor for Embedding layer.
This is based on the inputs, mask, and the inner layer.
If batch size is specified:
Simply return the input mask
. (An rnn-based implementation with
more than one rnn inputs is required but not supported in tf.keras yet.)
Otherwise we call compute_mask
of the inner layer at each time step.
If the output mask at each time step is not None
:
(E.g., inner layer is Masking or RNN)
Concatenate all of them and return the concatenation.
If the output mask at each time step is None
and the input mask is not
None
:(E.g., inner layer is Dense)
Reduce the input_mask to 2 dimensions and return it.
Otherwise (both the output mask and the input mask are None
):
(E.g., mask
is not used at all)
Return None
.
Arguments:
inputs
: Tensor with shape [batch size, timesteps, ...] indicating the input to TimeDistributed. If static shape information is available for "batch size",mask
is returned unmodified.mask
: Either None (indicating no masking) or a Tensor indicating the input mask for TimeDistributed. The shape can be static or dynamic.
Returns:
Either None (no masking), or a [batch size, timesteps, ...] Tensor with an output mask for the TimeDistributed layer with the shape beyond the second dimension being the value of the input mask shape(if the computed output mask is none), an output mask with the shape beyond the first dimension being the value of the mask shape(if mask is not None) or output mask with the shape beyond the first dimension being the value of the computed output shape.
tf.keras.layers.TimeDistributed.compute_output_shape
compute_output_shape(input_shape)
Computes the output shape of the layer.
Assumes that the layer will be built to match that input shape provided.
Arguments:
input_shape
: Shape tuple (tuple of integers) or list of shape tuples (one per output tensor of the layer). Shape tuples can include None for free dimensions, instead of an integer.
Returns:
An input shape tuple.
tf.keras.layers.TimeDistributed.count_params
count_params()
Count the total number of scalars composing the weights.
Returns:
An integer count.
Raises:
ValueError
: if the layer isn't yet built (in which case its weights aren't yet defined).
tf.keras.layers.TimeDistributed.from_config
from_config(
cls,
config,
custom_objects=None
)
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
).
Arguments:
config
: A Python dictionary, typically the output of get_config.
Returns:
A layer instance.
tf.keras.layers.TimeDistributed.get_config
get_config()
Returns the config of the layer.
A layer config is a Python dictionary (serializable) containing the configuration of a layer. The same layer can be reinstantiated later (without its trained weights) from this configuration.
The config of a layer does not include connectivity
information, nor the layer class name. These are handled
by Network
(one layer of abstraction above).
Returns:
Python dictionary.
tf.keras.layers.TimeDistributed.get_input_at
get_input_at(node_index)
Retrieves the input tensor(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A tensor (or list of tensors if the layer has multiple inputs).
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_input_mask_at
get_input_mask_at(node_index)
Retrieves the input mask tensor(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A mask tensor (or list of tensors if the layer has multiple inputs).
tf.keras.layers.TimeDistributed.get_input_shape_at
get_input_shape_at(node_index)
Retrieves the input shape(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A shape tuple (or list of shape tuples if the layer has multiple inputs).
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_losses_for
get_losses_for(inputs)
Retrieves losses relevant to a specific set of inputs.
Arguments:
inputs
: Input tensor or list/tuple of input tensors.
Returns:
List of loss tensors of the layer that depend on inputs
.
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_output_at
get_output_at(node_index)
Retrieves the output tensor(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A tensor (or list of tensors if the layer has multiple outputs).
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_output_mask_at
get_output_mask_at(node_index)
Retrieves the output mask tensor(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A mask tensor (or list of tensors if the layer has multiple outputs).
tf.keras.layers.TimeDistributed.get_output_shape_at
get_output_shape_at(node_index)
Retrieves the output shape(s) of a layer at a given node.
Arguments:
node_index
: Integer, index of the node from which to retrieve the attribute. E.g.node_index=0
will correspond to the first time the layer was called.
Returns:
A shape tuple (or list of shape tuples if the layer has multiple outputs).
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_updates_for
get_updates_for(inputs)
Retrieves updates relevant to a specific set of inputs.
Arguments:
inputs
: Input tensor or list/tuple of input tensors.
Returns:
List of update ops of the layer that depend on inputs
.
Raises:
RuntimeError
: If called in Eager mode.
tf.keras.layers.TimeDistributed.get_weights
get_weights()
Returns the current weights of the layer.
Returns:
Weights values as a list of numpy arrays.
tf.keras.layers.TimeDistributed.set_weights
set_weights(weights)
Sets the weights of the layer, from Numpy arrays.
Arguments:
weights
: a list of Numpy arrays. The number of arrays and their shape must match number of the dimensions of the weights of the layer (i.e. it should match the output ofget_weights
).
Raises:
ValueError
: If the provided weights list does not match the layer's specifications.