def call()

in tensorflow_model_remediation/min_diff/keras/models/min_diff_model.py [0:0]

• 12 lines of code
• 5 McCabe index (conditional complexity)

  def call(self, inputs, training=None, mask=None):
    # pyformat: disable
    """Calls `original_model` with optional `min_diff_loss` as regularization loss.

    Args:
      inputs: Inputs to original_model, optionally containing `min_diff_data` as
        described below.
      training: Boolean indicating whether to run in training or inference mode.
        See `tf.keras.Model.call` for details.
      mask: Mask or list of masks as described in `tf.keras.Model.call`.

    Note: Like `tf.keras.Model.call`, this method should not be called directly.
    To call a model on an input, always use the `__call__` method,
    i.e. `model(inputs)`, which relies on the `call` method internally.

    This method should be used the same way as `tf.keras.Model.call`. Depending
    on whether you are in train mode, `inputs` may need to include
    `min_diff_data` (see `MinDiffModel.compute_min_diff_data` for details on
    what form that needs to take).

    - If `training=True`: `inputs` must contain `min_diff_data` (see details
      below).
    - If `training=False`: including `min_diff_data` is optional.

    If present, the `min_diff_loss` is added by calling `self.add_loss` and will
    show up in `self.losses`.

    ```
    model = ...  # MinDiffModel.

    dataset = ...  # Dataset containing min_diff_data.

    for batch in dataset.take(1):
      model(batch, training=True)

    model.losses[0]  # First element(s) will be the min_diff_loss(es).
    ```

    Including `min_diff_data` in `inputs` implies that
    `MinDiffModel.unpack_original_inputs` and
    `MinDiffModel.unpack_min_diff_data` behave as expected when called on
    `inputs` (see methods for details).

    This condition is satisfied with the default implementations if you use
    `min_diff.keras.utils.pack_min_diff_data` to create the dataset that
    includes `min_diff_data`.


    Returns:
      A `tf.Tensor` or nested structure of `tf.Tensor`s according to the
      behavior `original_model`. See `tf.keras.Model.call` for details.

    Raises:
      ValueError: If `training` is set to `True` but `inputs` does not include
        `min_diff_data`.
    """
    # pyformat: enable
    original_inputs = self.unpack_original_inputs(inputs)
    min_diff_data = self.unpack_min_diff_data(inputs)

    # If training is True, we require min_diff_data to be available.
    if training and min_diff_data is None:
      raise ValueError(
          "call `inputs` must contain MinDiffData during training.")

    # Add min_diff_loss if min_diff_data is available.
    if min_diff_data is not None:
      min_diff_loss = self.compute_min_diff_loss(
          min_diff_data, training=training)
      # Add min_diff_loss(es) as regularization loss(es).
      tf.nest.map_structure(self.add_loss, min_diff_loss)

    return self._call_original_model(
        original_inputs, training=training, mask=mask)