keras-nightly 3.14.0.dev2026012104__py3-none-any.whl → 3.14.0.dev2026012304__py3-none-any.whl

keras/_tf_keras/keras/ops/__init__.py

@@ -245,6 +245,7 @@ from keras.src.ops.numpy import mod as mod
 from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
+from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

keras/_tf_keras/keras/ops/numpy/__init__.py

@@ -129,6 +129,7 @@ from keras.src.ops.numpy import mod as mod
 from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
+from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

keras/ops/__init__.py

@@ -245,6 +245,7 @@ from keras.src.ops.numpy import mod as mod
 from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
+from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

keras/ops/numpy/__init__.py

@@ -129,6 +129,7 @@ from keras.src.ops.numpy import mod as mod
 from keras.src.ops.numpy import moveaxis as moveaxis
 from keras.src.ops.numpy import multiply as multiply
 from keras.src.ops.numpy import nan_to_num as nan_to_num
+from keras.src.ops.numpy import nanmin as nanmin
 from keras.src.ops.numpy import nansum as nansum
 from keras.src.ops.numpy import ndim as ndim
 from keras.src.ops.numpy import negative as negative

keras/src/backend/jax/numpy.py

@@ -1013,6 +1013,11 @@ def moveaxis(x, source, destination):
     return jnp.moveaxis(x, source=source, destination=destination)
 
 
+def nanmin(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    return jnp.nanmin(x, axis=axis, keepdims=keepdims)
+
+
 def nansum(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     return jnp.nansum(x, axis=axis, keepdims=keepdims)

keras/src/backend/numpy/numpy.py

@@ -960,6 +960,10 @@ def moveaxis(x, source, destination):
     return np.moveaxis(x, source=source, destination=destination)
 
 
+def nanmin(x, axis=None, keepdims=False):
+    return np.nanmin(x, axis=axis, keepdims=keepdims)
+
+
 def nansum(x, axis=None, keepdims=False):
     axis = standardize_axis_for_numpy(axis)
     dtype = standardize_dtype(x.dtype)

keras/src/backend/openvino/numpy.py

@@ -1522,7 +1522,25 @@ def lcm(x1, x2):
 
 
 def ldexp(x1, x2):
-    raise NotImplementedError("`ldexp` is not supported with openvino backend")
+    element_type = None
+    if isinstance(x1, OpenVINOKerasTensor):
+        element_type = x1.output.get_element_type()
+    if isinstance(x2, OpenVINOKerasTensor):
+        element_type = x2.output.get_element_type()
+    x1 = get_ov_output(x1, element_type)
+    x2 = get_ov_output(x2, element_type)
+    x1, x2 = _align_operand_types(x1, x2, "ldexp()")
+
+    float_dtype = OPENVINO_DTYPES[config.floatx()]
+    if x1.get_element_type().is_integral():
+        x1 = ov_opset.convert(x1, float_dtype)
+    if x2.get_element_type().is_integral():
+        x2 = ov_opset.convert(x2, float_dtype)
+
+    const_two = ov_opset.constant(2, x2.get_element_type())
+    result = ov_opset.multiply(x1, ov_opset.power(const_two, x2))
+
+    return OpenVINOKerasTensor(result.output(0))
 
 
 def less(x1, x2):
@@ -1779,9 +1797,42 @@ def logaddexp(x1, x2):
 
 
 def logaddexp2(x1, x2):
-    raise NotImplementedError(
-        "`logaddexp2` is not supported with openvino backend"
+    element_type = None
+    if isinstance(x1, OpenVINOKerasTensor):
+        element_type = x1.output.get_element_type()
+    if isinstance(x2, OpenVINOKerasTensor):
+        element_type = x2.output.get_element_type()
+    x1 = get_ov_output(x1, element_type)
+    x2 = get_ov_output(x2, element_type)
+    x1, x2 = _align_operand_types(x1, x2, "logaddexp2()")
+
+    if x1.element_type.is_integral() or x2.element_type.is_integral():
+        float_dtype = OPENVINO_DTYPES[config.floatx()]
+        if x1.get_element_type().is_integral():
+            x1 = ov_opset.convert(x1, float_dtype)
+        if x2.get_element_type().is_integral():
+            x2 = ov_opset.convert(x2, float_dtype)
+
+    max_val = ov_opset.maximum(x1, x2)
+
+    sub = ov_opset.subtract(x1, x2)
+    abs_diff = ov_opset.abs(sub)
+
+    neg_abs_diff = ov_opset.negative(abs_diff)
+
+    element_type = neg_abs_diff.get_element_type()
+
+    two = ov_opset.constant(2, dtype=element_type)
+
+    power_of_2 = ov_opset.power(two, neg_abs_diff)
+
+    one_plus_power = ov_opset.add(
+        ov_opset.constant(1, dtype=element_type), power_of_2
     )
+    log2_term = ov_opset.divide(ov_opset.log(one_plus_power), ov_opset.log(two))
+    result = ov_opset.add(max_val, log2_term).output(0)
+
+    return OpenVINOKerasTensor(result)
 
 
 def logical_and(x1, x2):
@@ -2056,6 +2107,10 @@ def moveaxis(x, source, destination):
     return OpenVINOKerasTensor(ov_opset.transpose(x, axes_const).output(0))
 
 
+def nanmin(x, axis=None, keepdims=False):
+    raise NotImplementedError("`nanmin` is not supported with openvino backend")
+
+
 def nansum(x, axis=None, keepdims=False):
     raise NotImplementedError("`nansum` is not supported with openvino backend")
 
@@ -3155,7 +3210,20 @@ def correlate(x1, x2, mode="valid"):
 
 
 def select(condlist, choicelist, default=0):
-    raise NotImplementedError("`select` is not supported with openvino backend")
+    if len(condlist) != len(choicelist):
+        raise ValueError(
+            "select(): condlist and choicelist must have the same length"
+        )
+    conds = [get_ov_output(c) for c in condlist]
+    choices = [get_ov_output(v) for v in choicelist]
+
+    result = get_ov_output(default)
+    for cond_idx in reversed(range(len(conds))):
+        cond = conds[cond_idx]
+        choice = choices[cond_idx]
+        choice, result = _align_operand_types(choice, result, "select()")
+        result = ov_opset.select(cond, choice, result).output(0)
+    return OpenVINOKerasTensor(result)
 
 
 def slogdet(x):
@@ -3165,6 +3233,66 @@ def slogdet(x):
 
 
 def argpartition(x, kth, axis=-1):
-    raise NotImplementedError(
-        "`argpartition` is not supported with openvino backend"
+    x = get_ov_output(x)
+    x_shape = x.get_partial_shape()
+    rank = x_shape.rank.get_length()
+    axis = canonicalize_axis(axis, rank)
+    axes = list(range(rank))
+    axes[axis], axes[-1] = axes[-1], axes[axis]
+    x = ov_opset.transpose(x, ov_opset.constant(axes))
+    x_shape_tensor = ov_opset.shape_of(x)
+    n = ov_opset.gather(
+        x_shape_tensor,
+        ov_opset.constant(-1),
+        ov_opset.constant(0),
     )
+    if isinstance(kth, int) and kth < 0:
+        kth_tensor = ov_opset.add(
+            n,
+            ov_opset.constant(kth, n.get_element_type()),
+        )
+    else:
+        kth_tensor = ov_opset.constant(kth, n.get_element_type())
+    one = ov_opset.constant(1, kth_tensor.get_element_type())
+    k_val = ov_opset.add(kth_tensor, one)
+    bottom_ind = ov_opset.topk(
+        ov_opset.negative(x),
+        k=k_val,
+        axis=-1,
+        mode="max",
+        sort="value",
+    ).output(1)
+    one_hot_mask = ov_opset.one_hot(
+        bottom_ind,
+        n,
+        ov_opset.constant(1),
+        ov_opset.constant(0),
+        axis=-1,
+    )
+    mask = ov_opset.reduce_sum(
+        one_hot_mask,
+        ov_opset.constant([-2]),
+        keep_dims=False,
+    )
+    ones = ov_opset.broadcast(
+        ov_opset.constant(1),
+        x_shape_tensor,
+    )
+    proxy = ov_opset.subtract(ones, mask)
+    remaining_k = ov_opset.subtract(n, k_val)
+    top_ind = ov_opset.topk(
+        proxy,
+        k=remaining_k,
+        axis=-1,
+        mode="max",
+        sort="value",
+    ).output(1)
+    result = ov_opset.concat([bottom_ind, top_ind], axis=-1)
+    inv_axes = [0] * rank
+    for i, a in enumerate(axes):
+        inv_axes[a] = i
+    result = ov_opset.transpose(
+        result,
+        ov_opset.constant(inv_axes),
+    ).output(0)
+    return OpenVINOKerasTensor(result)

keras/src/backend/tensorflow/numpy.py

@@ -2125,6 +2125,26 @@ def moveaxis(x, source, destination):
     return tf.transpose(x, perm)
 
 
+def nanmin(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+
+    if not x.dtype.is_floating:
+        dtype = standardize_dtype(x.dtype)
+        if dtype == "bool":
+            return tf.reduce_all(x, axis=axis, keepdims=keepdims)
+        return tf.reduce_min(x, axis=axis, keepdims=keepdims)
+
+    x_clean = tf.where(
+        tf.math.is_nan(x), tf.constant(float("inf"), dtype=x.dtype), x
+    )
+
+    return tf.where(
+        tf.reduce_all(tf.math.is_nan(x), axis=axis, keepdims=keepdims),
+        tf.constant(float("nan"), dtype=x.dtype),
+        tf.reduce_min(x_clean, axis=axis, keepdims=keepdims),
+    )
+
+
 def nansum(x, axis=None, keepdims=False):
     x = convert_to_tensor(x)
     dtype = standardize_dtype(x.dtype)

keras/src/backend/torch/numpy.py

@@ -1272,6 +1272,24 @@ def moveaxis(x, source, destination):
     return torch.moveaxis(x, source=source, destination=destination)
 
 
+def nanmin(x, axis=None, keepdims=False):
+    x = convert_to_tensor(x)
+    if not torch.is_floating_point(x):
+        return torch.amin(x, dim=axis, keepdim=keepdims)
+
+    if axis == () or axis == []:
+        return x
+
+    x_clean = torch.where(torch.isnan(x), float("inf"), x)
+    out = torch.amin(x_clean, dim=axis, keepdim=keepdims)
+
+    return torch.where(
+        torch.isnan(x).all(dim=axis, keepdim=keepdims),
+        torch.tensor(float("nan"), dtype=x.dtype, device=get_device()),
+        out,
+    )
+
+
 def nansum(x, axis=None, keepdims=False):
     if isinstance(x, (list, tuple)):
         x = stack(x)

keras/src/layers/layer.py

@@ -27,6 +27,7 @@ from keras.src import backend
 from keras.src import constraints
 from keras.src import dtype_policies
 from keras.src import initializers
+from keras.src import ops
 from keras.src import regularizers
 from keras.src import tree
 from keras.src import utils
@@ -974,7 +975,15 @@ class Layer(BackendLayer, Operation):
                 if self.activity_regularizer is not None:
                     for output in tree.flatten(outputs):
                         if backend.is_tensor(output):
-                            self.add_loss(self.activity_regularizer(output))
+                            loss = self.activity_regularizer(output)
+                            if output.ndim > 0:
+                                # Normalize by batch size to ensure consistent
+                                # regularization strength across batch sizes
+                                batch_size = ops.cast(
+                                    ops.shape(output)[0], dtype=loss.dtype
+                                )
+                                loss = ops.divide_no_nan(loss, batch_size)
+                            self.add_loss(loss)
 
             # Set `previous_mask` on outputs if available. It is provided only
             # for the first positional input arg and its mask.

keras/src/layers/preprocessing/image_preprocessing/aug_mix.py

@@ -5,6 +5,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_transform_example,
+)
 from keras.src.random import SeedGenerator
 from keras.src.utils import backend_utils
 
@@ -71,6 +74,10 @@ class AugMix(BaseImagePreprocessingLayer):
         interpolation: The interpolation method to use for resizing operations.
             Options include `"nearest"`, `"bilinear"`. Default is `"bilinear"`.
         seed: Integer. Used to create a random seed.
+
+    Example:
+
+    {{base_image_preprocessing_transform_example}}
     """
 
     _USE_BASE_FACTOR = False
@@ -326,3 +333,9 @@ class AugMix(BaseImagePreprocessingLayer):
         }
         base_config = super().get_config()
         return {**base_config, **config}
+
+
+AugMix.__doc__ = AugMix.__doc__.replace(
+    "{{base_image_preprocessing_transform_example}}",
+    base_image_preprocessing_transform_example.replace("{LayerName}", "AugMix"),
+)

keras/src/layers/preprocessing/image_preprocessing/base_image_preprocessing_layer.py

@@ -383,3 +383,61 @@ class BaseImagePreprocessingLayer(DataLayer):
         )
 
         return affine_matrix
+
+
+base_image_preprocessing_transform_example = """
+```python
+layer = keras.layers.{LayerName}(bounding_box_format="xyxy")
+images = np.random.randint(0, 255, (4, 224, 224, 3), dtype="uint8")
+
+bounding_boxes = {
+    "boxes": np.array([
+        [[10, 20, 100, 150], [50, 60, 200, 250]],
+        [[15, 25, 110, 160], [55, 65, 210, 260]],
+        [[20, 30, 120, 170], [60, 70, 220, 270]],
+        [[25, 35, 130, 180], [65, 75, 230, 280]],
+    ], dtype="float32"),
+    "labels": np.array([[0, 1], [1, 2], [2, 3], [0, 3]], dtype="int32")
+}
+
+labels = keras.ops.one_hot(
+    np.array([0, 1, 2, 3]),
+    num_classes=4
+)
+
+segmentation_masks = np.random.randint(0, 3, (4, 224, 224, 1), dtype="uint8")
+
+output = layer(
+    {
+        "images": images,
+        "bounding_boxes": bounding_boxes,
+        "labels": labels,
+        "segmentation_masks": segmentation_masks
+    },
+    training=True
+)
+```
+"""
+
+base_image_preprocessing_color_example = """
+```python
+layer = keras.layers.{LayerName}(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
+)
+```
+"""

keras/src/layers/preprocessing/image_preprocessing/cut_mix.py

@@ -2,6 +2,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_color_example,
+)
 from keras.src.random import SeedGenerator
 
 
@@ -29,6 +32,10 @@ class CutMix(BaseImagePreprocessingLayer):
             in patch sizes, leading to more diverse and larger mixed patches.
             Defaults to 1.
         seed: Integer. Used to create a random seed.
+
+    Example:
+
+    {{base_image_preprocessing_color_example}}
     """
 
     _USE_BASE_FACTOR = False
@@ -227,3 +234,9 @@ class CutMix(BaseImagePreprocessingLayer):
         }
         base_config = super().get_config()
         return {**base_config, **config}
+
+
+CutMix.__doc__ = CutMix.__doc__.replace(
+    "{{base_image_preprocessing_color_example}}",
+    base_image_preprocessing_color_example.replace("{LayerName}", "CutMix"),
+)

keras/src/layers/preprocessing/image_preprocessing/max_num_bounding_box.py

@@ -15,6 +15,29 @@ class MaxNumBoundingBoxes(BaseImagePreprocessingLayer):
         max_number: Desired output number of bounding boxes.
         padding_value: The padding value of the `boxes` and `labels` in
             `bounding_boxes`. Defaults to `-1`.
+
+    Example:
+
+    ```python
+    max_boxes_layer = keras.layers.MaxNumBoundingBoxes(
+        max_number=10,
+        fill_value=-1
+    )
+
+    images = np.random.randint(0, 255, (1, 224, 224, 3), dtype="uint8")
+
+    bounding_boxes = {
+        "boxes": np.array([
+            [[10, 20, 100, 150], [50, 60, 200, 250], [0, 0, 50, 50]],
+        ]),
+        "labels": np.array([[1, 2, 3]])
+    }
+
+    result = max_boxes_layer({
+        "images": images,
+        "bounding_boxes": bounding_boxes
+    })
+    ```
     """
 
     def __init__(self, max_number, fill_value=-1, **kwargs):

keras/src/layers/preprocessing/image_preprocessing/rand_augment.py

@@ -3,6 +3,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_transform_example,
+)
 from keras.src.random import SeedGenerator
 from keras.src.utils import backend_utils
 
@@ -32,6 +35,10 @@ class RandAugment(BaseImagePreprocessingLayer):
         interpolation: The interpolation method to use for resizing operations.
             Options include `nearest`, `bilinear`. Default is `bilinear`.
         seed: Integer. Used to create a random seed.
+
+    Example:
+
+    {{base_image_preprocessing_transform_example}}
     """
 
     _USE_BASE_FACTOR = False
@@ -265,3 +272,11 @@ class RandAugment(BaseImagePreprocessingLayer):
         }
         base_config = super().get_config()
         return {**base_config, **config}
+
+
+RandAugment.__doc__ = RandAugment.__doc__.replace(
+    "{{base_image_preprocessing_transform_example}}",
+    base_image_preprocessing_transform_example.replace(
+        "{LayerName}", "RandAugment"
+    ),
+)

keras/src/layers/preprocessing/image_preprocessing/random_color_degeneration.py

@@ -2,6 +2,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_color_example,
+)
 from keras.src.random import SeedGenerator
 
 
@@ -29,6 +32,10 @@ class RandomColorDegeneration(BaseImagePreprocessingLayer):
             passed float is sampled. In order to ensure the value is always the
             same, please pass a tuple with two identical floats: `(0.5, 0.5)`.
         seed: Integer. Used to create a random seed.
+
+    Example:
+
+    {{base_image_preprocessing_color_example}}
     """
 
     _VALUE_RANGE_VALIDATION_ERROR = (
@@ -133,3 +140,11 @@ class RandomColorDegeneration(BaseImagePreprocessingLayer):
 
     def compute_output_shape(self, input_shape):
         return input_shape
+
+
+RandomColorDegeneration.__doc__ = RandomColorDegeneration.__doc__.replace(
+    "{{base_image_preprocessing_color_example}}",
+    base_image_preprocessing_color_example.replace(
+        "{LayerName}", "RandomColorDegeneration"
+    ),
+)

keras/src/layers/preprocessing/image_preprocessing/random_color_jitter.py

@@ -6,6 +6,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_color_example,
+)
 from keras.src.random.seed_generator import SeedGenerator
 from keras.src.utils import backend_utils
 
@@ -60,6 +63,10 @@ class RandomColorJitter(BaseImagePreprocessingLayer):
             always the same, please pass a tuple with two identical
             floats: `(0.5, 0.5)`.
         seed: Integer. Used to create a random seed.
+
+    Example:
+
+    {{base_image_preprocessing_color_example}}
     """
 
     def __init__(
@@ -211,3 +218,11 @@ class RandomColorJitter(BaseImagePreprocessingLayer):
         }
         base_config = super().get_config()
         return {**base_config, **config}
+
+
+RandomColorJitter.__doc__ = RandomColorJitter.__doc__.replace(
+    "{{base_image_preprocessing_color_example}}",
+    base_image_preprocessing_color_example.replace(
+        "{LayerName}", "RandomColorJitter"
+    ),
+)

keras/src/layers/preprocessing/image_preprocessing/random_contrast.py

@@ -2,6 +2,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_color_example,
+)
 from keras.src.random.seed_generator import SeedGenerator
 
 
@@ -45,6 +48,10 @@ class RandomContrast(BaseImagePreprocessingLayer):
             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:
+
+    {{base_image_preprocessing_color_example}}
     """
 
     _FACTOR_BOUNDS = (0, 1)
@@ -147,3 +154,11 @@ class RandomContrast(BaseImagePreprocessingLayer):
         }
         base_config = super().get_config()
         return {**base_config, **config}
+
+
+RandomContrast.__doc__ = RandomContrast.__doc__.replace(
+    "{{base_image_preprocessing_color_example}}",
+    base_image_preprocessing_color_example.replace(
+        "{LayerName}", "RandomContrast"
+    ),
+)

keras/src/layers/preprocessing/image_preprocessing/random_crop.py

@@ -3,6 +3,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_transform_example,
+)
 from keras.src.layers.preprocessing.image_preprocessing.bounding_boxes.converters import (  # noqa: E501
     convert_format,
 )
@@ -47,6 +50,10 @@ class RandomCrop(BaseImagePreprocessingLayer):
         seed: Integer. Used to create a random seed.
         **kwargs: Base layer keyword arguments, such as
             `name` and `dtype`.
+
+    Example:
+
+    {{base_image_preprocessing_transform_example}}
     """
 
     def __init__(
@@ -274,3 +281,11 @@ class RandomCrop(BaseImagePreprocessingLayer):
             }
         )
         return config
+
+
+RandomCrop.__doc__ = RandomCrop.__doc__.replace(
+    "{{base_image_preprocessing_transform_example}}",
+    base_image_preprocessing_transform_example.replace(
+        "{LayerName}", "RandomCrop"
+    ),
+)

keras/src/layers/preprocessing/image_preprocessing/random_elastic_transform.py

@@ -2,6 +2,9 @@ from keras.src.api_export import keras_export
 from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
     BaseImagePreprocessingLayer,
 )
+from keras.src.layers.preprocessing.image_preprocessing.base_image_preprocessing_layer import (  # noqa: E501
+    base_image_preprocessing_transform_example,
+)
 from keras.src.random.seed_generator import SeedGenerator
 
 
@@ -62,6 +65,9 @@ class RandomElasticTransform(BaseImagePreprocessingLayer):
             preprocessing pipeline is set up.
         seed: Integer. Used to create a random seed.
 
+    Example:
+
+    {{base_image_preprocessing_transform_example}}
     """
 
     _USE_BASE_FACTOR = False
@@ -277,3 +283,11 @@ class RandomElasticTransform(BaseImagePreprocessingLayer):
             "seed": self.seed,
         }
         return {**base_config, **config}
+
+
+RandomElasticTransform.__doc__ = RandomElasticTransform.__doc__.replace(
+    "{{base_image_preprocessing_transform_example}}",
+    base_image_preprocessing_transform_example.replace(
+        "{LayerName}", "RandomElasticTransform"
+    ),
+)