Module `delta.extensions.layers.pretrained`

Use a pretrained model inside another network.

Functions

def pretrained(filename, encoding_layer, outputs: Optional[List[str]] = None, trainable: bool = True, training: bool = True, **kwargs)

Creates pre-trained layer from an existing model file. Only works with sequential models. This was quite tricky to get right with tensorflow.

Parameters

filename : str: Model file to load.
encoding_layer : str: Name of the layer to stop at.
outputs : Optional[List[str]]: List of names of output layers that may be used later in the model. Only layers listed here will be accessible as inputs to other layers, in the form this_layer_name/internal_name. (internal_name must be included in outputs to do so)
trainable : bool: Whether to update weights during training for this layer.
training : bool: Standard tensorflow option, used for batch norm layers.

Classes

class InputSelectLayer (arg_number, **kwargs)

A layer that takes any number of inputs, and returns a given one.

Parameters

arg_number : int: The index of the input to select.

Expand source code

class InputSelectLayer(tensorflow.keras.layers.Layer):
    """
    A layer that takes any number of inputs, and returns a given one.
    """
    def __init__(self, arg_number, **kwargs):
        """
        Parameters
        ----------
        arg_number: int
            The index of the input to select.
        """
        super().__init__(**kwargs)
        self._arg = arg_number
    def call(self, inputs, **kwargs): #pylint: disable=unused-argument,arguments-differ
        return inputs[self._arg]
    def get_config(self):
        return {'arg_number' : self._arg}

Ancestors

keras.src.engine.base_layer.Layer
tensorflow.python.module.module.Module
tensorflow.python.trackable.autotrackable.AutoTrackable
tensorflow.python.trackable.base.Trackable
keras.src.utils.version_utils.LayerVersionSelector

Methods

def call(self, inputs, **kwargs)

This is where the layer's logic lives.

The call() method may not create state (except in its first invocation, wrapping the creation of variables or other resources in tf.init_scope()). It is recommended to create state, including tf.Variable instances and nested Layer instances, in __init__(), or in the build() method that is called automatically before call() executes for the first time.

Args

inputs: Input tensor, or dict/list/tuple of input tensors. The first positional inputs argument is subject to special rules: - inputs must be explicitly passed. A layer cannot have zero arguments, and inputs cannot be provided via the default value of a keyword argument. - NumPy array or Python scalar values in inputs get cast as tensors. - Keras mask metadata is only collected from inputs. - Layers are built (build(input_shape) method) using shape info from inputs only. - input_spec compatibility is only checked against inputs. - Mixed precision input casting is only applied to inputs. If a layer has tensor arguments in *args or **kwargs, their casting behavior in mixed precision should be handled manually. - The SavedModel input specification is generated using inputs only. - Integration with various ecosystem packages like TFMOT, TFLite, TF.js, etc is only supported for inputs and not for tensors in positional and keyword arguments.
*args: Additional positional arguments. May contain tensors, although this is not recommended, for the reasons above.
**kwargs: Additional keyword arguments. May contain tensors, although this is not recommended, for the reasons above. The following optional keyword arguments are reserved: - training: Boolean scalar tensor of Python boolean indicating whether the call is meant for training or inference. - mask: Boolean input mask. If the layer's call() method takes a mask argument, its default value will be set to the mask generated for inputs by the previous layer (if input did come from a layer that generated a corresponding mask, i.e. if it came from a Keras layer with masking support).

Returns

A tensor or list/tuple of tensors.

def get_config(self)

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

Note that get_config() does not guarantee to return a fresh copy of dict every time it is called. The callers should make a copy of the returned dict if they want to modify it.

Returns

Python dictionary.