merlin.models.tf.SequentialBlock#

class merlin.models.tf.SequentialBlock(*args, **kwargs)[source]#

Bases: merlin.models.tf.core.base.Block

The SequentialLayer represents a sequence of Keras layers. It is a Keras Layer that can be used instead of tf.keras.layers.Sequential, which is actually a Keras Model. In contrast to keras Sequential, this layer can be used as a pure Layer in tf.functions and when exporting SavedModels, without having to pre-declare input and output shapes. In turn, this layer is usable as a preprocessing layer for TF Agents Networks, and can be exported via PolicySaver. Usage:

c = SequentialLayer([layer1, layer2, layer3])
output = c(inputs)    # Equivalent to: output = layer3(layer2(layer1(inputs)))

__init__(*layers, filter: Optional[Union[merlin.schema.schema.Schema, merlin.schema.tags.Tags, List[str], merlin.models.tf.core.tabular.Filter]] = None, pre_aggregation: Optional[Union[str, merlin.models.tf.core.tabular.TabularAggregation]] = None, block_name: Optional[str] = None, copy_layers: bool = False, **kwargs)[source]#

Create a sequential composition.

Parameters

layers – A list or tuple of layers to compose.
**kwargs – Arguments to pass to Keras layer initializer, including name.

Raises

TypeError: – If any of the layers are not instances of keras Layer.

Methods

`__init__`(*layers[, filter, pre_aggregation, ...])	Create a sequential composition.
`add_loss`(losses, **kwargs)	Add loss tensor(s), potentially dependent on layer inputs.
`add_metric`(value[, name])	Adds metric tensor to the layer.
`add_update`(updates)	Add update op(s), potentially dependent on layer inputs.
`add_variable`(args, *kwargs)	Deprecated, do NOT use! Alias for add_weight.
`add_weight`([name, shape, dtype, ...])	Adds a new variable to the layer.
`as_tabular`([name])
`build`([input_shape])	Builds the sequential block
`build_from_config`(config)
`call`(inputs[, training])
`call_outputs`(outputs[, training])
`check_schema`([schema])
`compute_loss`(inputs, targets, **kwargs)
`compute_mask`(inputs[, mask])	Computes an output mask tensor.
`compute_output_shape`(input_shape)	Computes the output shape based on the input shape
`compute_output_signature`(input_signature)
`connect`(*block[, block_name, context])	Connect the block to other blocks sequentially.
`connect_branch`(*branches[, add_rest, post, ...])	Connect the block to one or multiple branches.
`connect_debug_block`([append])	Connect the block to a debug block.
`connect_with_residual`(block[, activation])	Connect the block to other blocks sequentially with a residual connection.
`connect_with_shortcut`(block[, ...])	Connect the block to other blocks sequentially with a shortcut connection.
`copy`()
`count_params`()	Count the total number of scalars composing the weights.
`finalize_state`()	Finalizes the layers state after updating layer weights.
`from_config`(config[, custom_objects])
`from_layer`(layer)
`get_build_config`()
`get_config`()
`get_input_at`(node_index)	Retrieves the input tensor(s) of a layer at a given node.
`get_input_mask_at`(node_index)	Retrieves the input mask tensor(s) of a layer at a given node.
`get_input_shape_at`(node_index)	Retrieves the input shape(s) of a layer at a given node.
`get_item_ids_from_inputs`(inputs)
`get_output_at`(node_index)	Retrieves the output tensor(s) of a layer at a given node.
`get_output_mask_at`(node_index)	Retrieves the output mask tensor(s) of a layer at a given node.
`get_output_shape_at`(node_index)	Retrieves the output shape(s) of a layer at a given node.
`get_padding_mask_from_item_id`(inputs[, ...])
`get_weights`()	Returns the current weights of the layer, as NumPy arrays.
`parse`(*block)
`parse_block`(input)
`prepare`([block, post, aggregation])	Transform the inputs of this block.
`register_features`(feature_shapes)
`repeat`([num])	Repeat the block num times.
`repeat_in_parallel`([num, prefix, names, ...])	Repeat the block num times in parallel.
`select_by_name`(name)
`select_by_tag`(tags)
`set_schema`([schema])
`set_weights`(weights)	Sets the weights of the layer, from NumPy arrays.
`with_name_scope`(method)	Decorator to automatically enter the module name scope.

Attributes

`REQUIRES_SCHEMA`
`activity_regularizer`	Optional regularizer function for the output of this layer.
`compute_dtype`	The dtype of the layer's computations.
`context`
`dtype`	The dtype of the layer weights.
`dtype_policy`	The dtype policy associated with this layer.
`dynamic`	Whether the layer is dynamic (eager-only); set in the constructor.
`filter_features`
`first`	Returns the first block in the SequenceBlock
`has_schema`
`inbound_nodes`	Return Functional API nodes upstream of this layer.
`input`	Retrieves the input tensor(s) of a layer.
`input_mask`	Retrieves the input mask tensor(s) of a layer.
`input_shape`	Retrieves the input shape(s) of a layer.
`input_spec`	InputSpec instance(s) describing the input format for this layer.
`inputs`	Returns the InputBlock, if it is the first block within SequenceBlock
`is_tabular`
`last`	Returns the last block in the SequenceBlock
`losses`
`metrics`	List of metrics added using the add_metric() API.
`name`	Name of the layer (string), set in the constructor.
`name_scope`	Returns a tf.name_scope instance for this class.
`non_trainable_variables`
`non_trainable_weights`	Returns non-trainable weights of all layers of this block
`outbound_nodes`	Return Functional API nodes downstream of this layer.
`output`	Retrieves the output tensor(s) of a layer.
`output_mask`	Retrieves the output mask tensor(s) of a layer.
`output_shape`	Retrieves the output shape(s) of a layer.
`registry`
`regularizers`
`schema`
`stateful`
`submodules`	Sequence of all sub-modules.
`supports_masking`	Whether this layer supports computing a mask using compute_mask.
`trainable`	Returns whether all layer within SequentialBlock are trainable
`trainable_variables`
`trainable_weights`	Returns trainable weights of all layers of this block
`updates`
`variable_dtype`	Alias of Layer.dtype, the dtype of the weights.
`variables`	Returns the list of all layer variables/weights.
`weights`	Returns the list of all layer variables/weights.

compute_output_shape(input_shape)[source]#

Computes the output shape based on the input shape

Parameters: input_shape (tf.TensorShape) – The input shape
Returns: The output shape
Return type: tf.TensorShape

compute_output_signature(input_signature)[source]#

build(input_shape=None)[source]#

Builds the sequential block

Parameters: input_shape (tf.TensorShape, optional) – The input shape, by default None

set_schema(schema=None)[source]#

property inputs#

Returns the InputBlock, if it is the first block within SequenceBlock

Returns: The input block
Return type: InputBlock

property first#

Returns the first block in the SequenceBlock

Returns: The first block of SequenceBlock
Return type: Block

property last#

Returns the last block in the SequenceBlock

Returns: The last block of SequenceBlock
Return type: Block

property filter_features: List[str]#

property trainable_weights#

Returns trainable weights of all layers of this block

Returns: List with trainable weights
Return type: List

property non_trainable_weights#

Returns non-trainable weights of all layers of this block

Returns: List with non-trainable weights
Return type: List

property trainable#

Returns whether all layer within SequentialBlock are trainable

Returns: True if any layer within SequentialBlock are trainable, otherwise False
Return type: bool

property losses#

property regularizers#

call(inputs, training=False, **kwargs)[source]#

compute_loss(inputs, targets, **kwargs)[source]#

call_outputs(outputs: merlin.models.tf.core.base.PredictionOutput, training=False, **kwargs) → merlin.models.tf.core.base.PredictionOutput[source]#

get_config()[source]#

property is_tabular#

classmethod from_config(config, custom_objects=None)[source]#