tf.keras.layers.RandomErasing

tf.keras.layers.RandomErasing(
    factor=1.0,
    scale=(0.02, 0.33),
    fill_value=None,
    value_range=(0, 255),
    seed=None,
    data_format=None,
    **kwargs
)

Random Erasing is a data augmentation method where random patches of
an image are erased (replaced by a constant value or noise)
during training to improve generalization.

Note: This layer is safe to use inside a <a href="../../../tf/data"><code>tf.data</code></a> or `grain` pipeline
(independently of which backend you're using).

References:

   - [Random Erasing paper](https://arxiv.org/abs/1708.04896).

Args:
    factor: A single float or a tuple of two floats.
        `factor` controls the probability of applying the transformation.

        - `factor=0.0` ensures no erasing is applied.
        - `factor=1.0` means erasing is always applied.
        - If a tuple `(min, max)` is provided, a probability value
          is sampled between `min` and `max` for each image.
        - If a single float is provided, a probability is sampled
          between `0.0` and the given float.
        Default is 1.0.
    scale: A tuple of two floats representing the aspect ratio range of
        the erased patch. This defines the width-to-height ratio of
        the patch to be erased. It can help control the rw shape of
        the erased region. Default is (0.02, 0.33).
    fill_value: A value to fill the erased region with. This can be set to
        a constant value or `None` to sample a random value
        from a normal distribution. Default is `None`.
    value_range: the range of values the incoming images will have.
        Represented as a two-number tuple written `[low, high]`. This is
        typically either `[0, 1]` or `[0, 255]` depending on how your
        preprocessing pipeline is set up.
    seed: Integer. Used to create a random seed.

Example:

layer = keras.layers.RandomErasing(value_range=(0, 255))
images = np.random.randint(0, 255, (8, 224, 224, 3), dtype="uint8")

labels = keras.ops.one_hot(
    np.array([0, 1, 2, 0, 1, 2, 0, 1]),
    num_classes=3
)

segmentation_masks = np.random.randint(0, 3, (8, 224, 224, 1), dtype="uint8")

output = layer(
    {
        "images": images,
        "labels": labels,
        "segmentation_masks": segmentation_masks
    },
    training=True
)

convert_weight(
    weight
)

@classmethod
from_config(
    config
)

if "dtype" in config and isinstance(config["dtype"], dict):
    policy = dtype_policies.deserialize(config["dtype"])

get_random_transformation(
    data, training=True, seed=None
)

transform_bounding_boxes(
    bounding_boxes, transformation, training=True
)

transform_images(
    images, transformation=None, training=True
)

transform_labels(
    labels, transformation, training=True
)

transform_segmentation_masks(
    segmentation_masks, transformation, training=True
)

transform_single_bounding_box(
    bounding_box, transformation, training=True
)

transform_single_image(
    image, transformation, training=True
)

transform_single_label(
    label, transformation, training=True
)

transform_single_segmentation_mask(
    segmentation_mask, transformation, training=True
)