tf.keras.layers.RandomColorJitter

tf.keras.layers.RandomColorJitter(
    value_range=(0, 255),
    brightness_factor=None,
    contrast_factor=None,
    saturation_factor=None,
    hue_factor=None,
    seed=None,
    data_format=None,
    **kwargs
)

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

Args:
    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.
    brightness_factor: Float or a list/tuple of 2 floats between -1.0
        and 1.0. The factor is used to determine the lower bound and
        upper bound of the brightness adjustment. A float value will
        be chosen randomly between the limits. When -1.0 is chosen,
        the output image will be black, and when 1.0 is chosen, the
        image will be fully white. When only one float is provided,
        eg, 0.2, then -0.2 will be used for lower bound and 0.2 will
        be used for upper bound.
    contrast_factor: a positive float represented as fraction of value,
        or a tuple of size 2 representing lower and upper bound. When
        represented as a single float, lower = upper. The contrast
        factor will be randomly picked between `[1.0 - lower, 1.0 +
        upper]`. For any pixel x in the channel, the output will be
        `(x - mean) * factor + mean` where `mean` is the mean value
        of the channel.
    saturation_factor: A tuple of two floats or a single float. `factor`
        controls the extent to which the image saturation is impacted.
        `factor=0.5` makes this layer perform a no-op operation.
        `factor=0.0` makes the image fully grayscale. `factor=1.0`
        makes the image fully saturated. Values should be between
        `0.0` and `1.0`. If a tuple is used, a `factor` is sampled
        between the two values for every image augmented. If a single
        float is used, a value between `0.0` and the passed float is
        sampled. To ensure the value is always the same, pass a tuple
        with two identical floats: `(0.5, 0.5)`.
    hue_factor: A single float or a tuple of two floats. `factor`
        controls the extent to which the image hue is impacted.
        `factor=0.0` makes this layer perform a no-op operation,
        while a value of `1.0` performs the most aggressive contrast
        adjustment available. If a tuple is used, a `factor` is
        sampled between the two values for every image augmented.
        If a single float is used, a value between `0.0` and the
        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:

layer = keras.layers.RandomColorJitter(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, 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
)