tf.keras.Layer

View source on GitHub

This is the class from which all layers inherit.

Inherits From: Operation

View aliases

Main aliases

tf.keras.layers.Layer

Compat aliases for migration

See Migration guide for more details.

tf.compat.v1.keras.Layer

tf.keras.Layer(
    *,
    activity_regularizer=None,
    trainable=True,
    dtype=None,
    autocast=True,
    name=None,
    **kwargs
)

Used in the notebooks

Used in the guide	Used in the tutorials
Use TF1.x models in TF2 workflows Validating correctness & numerical equivalence Introduction to modules, layers, and models Extension types Debug a TensorFlow 2 migrated training pipeline	Load text Scalable model compression Transfer learning with YAMNet for environmental sound classification Custom layers Data augmentation

A layer is a callable object that takes as input one or more tensors and that outputs one or more tensors. It involves computation, defined in the call() method, and a state (weight variables). State can be created:

in __init__(), for instance via self.add_weight();
in the optional build() method, which is invoked by the first __call__() to the layer, and supplies the shape(s) of the input(s), which may not have been known at initialization time.

Layers are recursively composable: If you assign a Layer instance as an attribute of another Layer, the outer layer will start tracking the weights created by the inner layer. Nested layers should be instantiated in the __init__() method or build() method.

Users will just instantiate a layer and then treat it as a callable.

Args
`trainable`	Boolean, whether the layer's variables should be trainable.
`name`	String name of the layer.
`dtype`	The dtype of the layer's computations and weights. Can also be a `keras.DTypePolicy`, which allows the computation and weight dtype to differ. Defaults to `None`. `None` means to use `keras.config.dtype_policy()`, which is a `float32` policy unless set to different value (via `keras.config.set_dtype_policy()`).

We recommend that descendants of Layer implement the following methods:

__init__(): Defines custom layer attributes, and creates layer weights that do not depend on input shapes, using add_weight(), or other state.
build(self, input_shape): This method can be used to create weights that depend on the shape(s) of the input(s), using add_weight(), or other state. __call__() will automatically build the layer (if it has not been built yet) by calling build().
call(self, *args, **kwargs): Called in __call__ after making sure build() has been called. call() performs the logic of applying the layer to the input arguments. Two reserved keyword arguments you can optionally use in call() are: 1. training (boolean, whether the call is in inference mode or training mode). 2. mask (boolean tensor encoding masked timesteps in the input, used e.g. in RNN layers). A typical signature for this method is call(self, inputs), and user could optionally add training and mask if the layer need them.
get_config(self): Returns a dictionary containing the configuration used to initialize this layer. If the keys differ from the arguments in __init__(), then override from_config(self) as well. This method is used when saving the layer or a model that contains this layer.

Examples:

Here's a basic example: a layer with two variables, w and b, that returns y = w . x + b. It shows how to implement build() and call(). Variables set as attributes of a layer are tracked as weights of the layers (in layer.weights).

class SimpleDense(Layer):
    def __init__(self, units=32):
        super().__init__()
        self.units = units

    # Create the state of the layer (weights)
    def build(self, input_shape):
        self.kernel = self.add_weight(
            shape=(input_shape[-1], self.units),
            initializer="glorot_uniform",
            trainable=True,
            name="kernel",
        )
        self.bias = self.add_weight(
            shape=(self.units,),
            initializer="zeros",
            trainable=True,
            name="bias",
        )

    # Defines the computation
    def call(self, inputs):
        return ops.matmul(inputs, self.kernel) + self.bias

# Instantiates the layer.
linear_layer = SimpleDense(4)

# This will also call `build(input_shape)` and create the weights.
y = linear_layer(ops.ones((2, 2)))
assert len(linear_layer.weights) == 2

# These weights are trainable, so they're listed in `trainable_weights`:
assert len(linear_layer.trainable_weights) == 2

Besides trainable weights, updated via backpropagation during training, layers can also have non-trainable weights. These weights are meant to be updated manually during call(). Here's a example layer that computes the running sum of its inputs:

class ComputeSum(Layer):

  def __init__(self, input_dim):
      super(ComputeSum, self).__init__()
      # Create a non-trainable weight.
      self.total = self.add_weight(
        shape=(),
        initializer="zeros",
        trainable=False,
        name="total",
      )

  def call(self, inputs):
      self.total.assign(self.total + ops.sum(inputs))
      return self.total

my_sum = ComputeSum(2)
x = ops.ones((2, 2))
y = my_sum(x)

assert my_sum.weights == [my_sum.total]
assert my_sum.non_trainable_weights == [my_sum.total]
assert my_sum.trainable_weights == []

Attributes
`name`	The name of the layer (string).
`dtype`	Dtype of the layer's weights. Alias of `layer.variable_dtype`.
`variable_dtype`	Dtype of the layer's weights.
`compute_dtype`	The dtype of the layer's computations. Layers automatically cast inputs to this dtype, which causes the computations and output to also be in this dtype. When mixed precision is used with a `keras.DTypePolicy`, this will be different than `variable_dtype`.
`trainable_weights`	List of variables to be included in backprop.
`non_trainable_weights`	List of variables that should not be included in backprop.
`weights`	The concatenation of the lists trainable_weights and non_trainable_weights (in this order).
`trainable`	Whether the layer should be trained (boolean), i.e. whether its potentially-trainable weights should be returned as part of `layer.trainable_weights`.
`input_spec`	Optional (list of) `InputSpec` object(s) specifying the constraints on inputs that can be accepted by the layer.
`dtype_policy`
`input`	Retrieves the input tensor(s) of a symbolic operation. Only returns the tensor(s) corresponding to the first time the operation was called.
`input_dtype`	The dtype layer inputs should be converted to.
`losses`	List of scalar losses from `add_loss`, regularizers and sublayers.
`metrics`	List of all metrics.
`metrics_variables`	List of all metric variables.
`non_trainable_variables`	List of all non-trainable layer state. This extends `layer.non_trainable_weights` to include all state used by the layer including state for metrics and `SeedGenerator`s.
`output`	Retrieves the output tensor(s) of a layer. Only returns the tensor(s) corresponding to the first time the operation was called.
`supports_masking`	Whether this layer supports computing a mask using `compute_mask`.
`trainable_variables`	List of all trainable layer state. This is equivalent to `layer.trainable_weights`.
`variables`	List of all layer state, including random seeds. This extends `layer.weights` to include all state used by the layer including `SeedGenerator`s. Note that metrics variables are not included here, use `metrics_variables` to visit all the metric variables.

Args
`shape`	Shape tuple for the variable. Must be fully-defined (no `None` entries). Defaults to `()` (scalar) if unspecified.
`initializer`	Initializer object to use to populate the initial variable value, or string name of a built-in initializer (e.g. `"random_normal"`). If unspecified, defaults to `"glorot_uniform"` for floating-point variables and to `"zeros"` for all other types (e.g. int, bool).
`dtype`	Dtype of the variable to create, e.g. `"float32"`. If unspecified, defaults to the layer's variable dtype (which itself defaults to `"float32"` if unspecified).
`trainable`	Boolean, whether the variable should be trainable via backprop or whether its updates are managed manually. Defaults to `True`.
`autocast`	Boolean, whether to autocast layers variables when accessing them. Defaults to `True`.
`regularizer`	Regularizer object to call to apply penalty on the weight. These penalties are summed into the loss function during optimization. Defaults to `None`.
`constraint`	Contrainst object to call on the variable after any optimizer update, or string name of a built-in constraint. Defaults to `None`.
`aggregation`	String, one of `'mean'`, `'sum'`, `'only_first_replica'`. Annotates the variable with the type of multi-replica aggregation to be used for this variable when writing custom data parallel training loops.
`name`	String name of the variable. Useful for debugging purposes.

Args
`trainable_variables`	List of trainable variables of the model.
`non_trainable_variables`	List of non-trainable variables of the model.
`*args`	Positional arguments to be passed to `call()`.
`return_losses`	If `True`, `stateless_call()` will return the list of losses created during `call()` as part of its return values.
`**kwargs`	Keyword arguments to be passed to `call()`.

tf.keras.Layer

View aliases

Used in the notebooks

Args

Examples:

Attributes

Methods

add_loss

Example:

add_metric

add_variable

add_weight

build

build_from_config

call

compute_mask

compute_output_shape

compute_output_spec

count_params

from_config

get_build_config

get_config

get_weights

load_own_variables

quantize

quantized_call

save_own_variables

set_weights

stateless_call

Example:

symbolic_call

__call__

`add_loss`

`add_metric`

`add_variable`

`add_weight`

`build`

`build_from_config`

`call`

`compute_mask`

`compute_output_shape`

`compute_output_spec`

`count_params`

`from_config`

`get_build_config`

`get_config`

`get_weights`

`load_own_variables`

`quantize`

`quantized_call`

`save_own_variables`

`set_weights`

`stateless_call`

`symbolic_call`

`call`