keras-hub-nightly 0.15.0.dev20240823171555__py3-none-any.whl → 0.16.0.dev2024092017__py3-none-any.whl

keras_hub/src/bounding_box/validate_format.py

@@ -0,0 +1,99 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from keras_hub.src.api_export import keras_hub_export
+
+try:
+    import tensorflow as tf
+except ImportError:
+    tf = None
+
+
+@keras_hub_export("keras_hub.bounding_box.validate_format")
+def validate_format(bounding_boxes, variable_name="bounding_boxes"):
+    """validates that a given set of bounding boxes complies with KerasHub
+    format.
+
+    For a set of bounding boxes to be valid it must satisfy the following
+    conditions:
+    - `bounding_boxes` must be a dictionary
+    - contains keys `"boxes"` and `"classes"`
+    - each entry must have matching first two dimensions; representing the batch
+        axis and the number of boxes per image axis.
+    - either both `"boxes"` and `"classes"` are batched, or both are unbatched.
+
+    Additionally, one of the following must be satisfied:
+    - `"boxes"` and `"classes"` are both Ragged
+    - `"boxes"` and `"classes"` are both Dense
+    - `"boxes"` and `"classes"` are unbatched
+
+    Args:
+        bounding_boxes: dictionary of bounding boxes according to KerasCV
+        format.
+
+    Raises:
+        ValueError if any of the above conditions are not met
+    """
+    if not isinstance(bounding_boxes, dict):
+        raise ValueError(
+            f"Expected `{variable_name}` to be a dictionary, got "
+            f"`{variable_name}={bounding_boxes}`."
+        )
+    if not all([x in bounding_boxes for x in ["boxes", "classes"]]):
+        raise ValueError(
+            f"Expected `{variable_name}` to be a dictionary containing keys "
+            "`'classes'` and `'boxes'`. Got "
+            f"`{variable_name}.keys()={bounding_boxes.keys()}`."
+        )
+
+    boxes = bounding_boxes.get("boxes")
+    classes = bounding_boxes.get("classes")
+    info = {}
+
+    is_batched = len(boxes.shape) == 3
+    info["is_batched"] = is_batched
+    info["ragged"] = isinstance(boxes, tf.RaggedTensor)
+
+    if not is_batched:
+        if boxes.shape[:1] != classes.shape[:1]:
+            raise ValueError(
+                "Expected `boxes` and `classes` to have matching dimensions "
+                "on the first axis when operating in unbatched mode. Got "
+                f"`boxes.shape={boxes.shape}`, `classes.shape={classes.shape}`."
+            )
+
+        info["classes_one_hot"] = len(classes.shape) == 2
+        # No Ragged checks needed in unbatched mode.
+        return info
+
+    info["classes_one_hot"] = len(classes.shape) == 3
+
+    if isinstance(boxes, tf.RaggedTensor) != isinstance(
+        classes, tf.RaggedTensor
+    ):
+        raise ValueError(
+            "Either both `boxes` and `classes` "
+            "should be Ragged, or neither should be ragged."
+            f" Got `type(boxes)={type(boxes)}`, type(classes)={type(classes)}."
+        )
+
+    # Batched mode checks
+    if boxes.shape[:2] != classes.shape[:2]:
+        raise ValueError(
+            "Expected `boxes` and `classes` to have matching dimensions "
+            "on the first two axes when operating in batched mode. "
+            f"Got `boxes.shape={boxes.shape}`, `classes.shape={classes.shape}`."
+        )
+
+    return info

keras_hub/src/layers/preprocessing/audio_converter.py

@@ -0,0 +1,121 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.layers.preprocessing.preprocessing_layer import (
+    PreprocessingLayer,
+)
+from keras_hub.src.utils.preset_utils import AUDIO_CONVERTER_CONFIG_FILE
+from keras_hub.src.utils.preset_utils import builtin_presets
+from keras_hub.src.utils.preset_utils import find_subclass
+from keras_hub.src.utils.preset_utils import get_preset_loader
+from keras_hub.src.utils.preset_utils import save_serialized_object
+from keras_hub.src.utils.python_utils import classproperty
+
+
+@keras_hub_export("keras_hub.layers.AudioConverter")
+class AudioConverter(PreprocessingLayer):
+    """Convert raw audio for models that support audio input.
+
+    This class converts from raw audio tensors of any length, to preprocessed
+    audio for pretrained model inputs. It is meant to be a convenient way to
+    write custom preprocessing code that is not model specific. This layer
+    should be instantiated via the `from_preset()` constructor, which will
+    create the correct subclass of this layer for the model preset.
+
+    The layer will take as input a raw audio tensor with shape `(batch_size,
+    num_samples)`, and output a preprocessed audio input for modeling. The exact
+    structure of the preprocessed input will vary per model. Preprocessing
+    will often include computing a spectogram of the raw audio signal.
+
+    Examples:
+    ```python
+    # Load an audio converter from a preset.
+    converter = keras_hub.layers.AudioConverter.from_preset("whisper_base_en")
+    # Convert some raw audio input.
+    converter(np.ones(2, 1_000))
+    ```
+    """
+
+    backbone_cls = None
+
+    def audio_shape(self):
+        """Returns the preprocessed size of a single audio sample."""
+        return (None,)
+
+    @classproperty
+    def presets(cls):
+        """List built-in presets for an `AudioConverter` subclass."""
+        return builtin_presets(cls)
+
+    @classmethod
+    def from_preset(
+        cls,
+        preset,
+        **kwargs,
+    ):
+        """Instantiate a `keras_hub.layers.AudioConverter` from a model preset.
+
+        A preset is a directory of configs, weights and other file assets used
+        to save and load a pre-trained model. The `preset` can be passed as
+        one of:
+
+        1. a built-in preset identifier like `'whisper_base_en'`
+        2. a Kaggle Models handle like
+           `'kaggle://user/whisper/keras/whisper_base_en'`
+        3. a Hugging Face handle like `'hf://user/whisper_base_en'`
+        4. a path to a local preset directory like `'./whisper_base_en'`
+
+        You can run `cls.presets.keys()` to list all built-in presets available
+        on the class.
+
+        This constructor can be called in one of two ways. Either from the base
+        class like `keras_hub.models.AudioConverter.from_preset()`, or from a
+        model class like `keras_hub.models.WhisperAudioConverter.from_preset()`.
+        If calling from the base class, the subclass of the returning object
+        will be inferred from the config in the preset directory.
+
+        Args:
+            preset: string. A built-in preset identifier, a Kaggle Models
+                handle, a Hugging Face handle, or a path to a local directory.
+            load_weights: bool. If `True`, the weights will be loaded into the
+                model architecture. If `False`, the weights will be randomly
+                initialized.
+
+        Examples:
+        ```python
+        # Load an audio converter from a preset.
+        converter = keras_hub.layers.AudioConverter.from_preset(
+            "whisper_base_en"
+        )
+        # Convert some raw mono channel audio input.
+        converter(np.ones(2, 1_000))
+        ```
+        """
+        loader = get_preset_loader(preset)
+        backbone_cls = loader.check_backbone_class()
+        if cls.backbone_cls != backbone_cls:
+            cls = find_subclass(preset, cls, backbone_cls)
+        return loader.load_audio_converter(cls, **kwargs)
+
+    def save_to_preset(self, preset_dir):
+        """Save audio converter to a preset directory.
+
+        Args:
+            preset_dir: The path to the local model preset directory.
+        """
+        save_serialized_object(
+            self,
+            preset_dir,
+            config_file=AUDIO_CONVERTER_CONFIG_FILE,
+        )

keras_hub/src/layers/preprocessing/image_converter.py

@@ -0,0 +1,130 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.layers.preprocessing.preprocessing_layer import (
+    PreprocessingLayer,
+)
+from keras_hub.src.utils.preset_utils import IMAGE_CONVERTER_CONFIG_FILE
+from keras_hub.src.utils.preset_utils import builtin_presets
+from keras_hub.src.utils.preset_utils import find_subclass
+from keras_hub.src.utils.preset_utils import get_preset_loader
+from keras_hub.src.utils.preset_utils import save_serialized_object
+from keras_hub.src.utils.python_utils import classproperty
+
+
+@keras_hub_export("keras_hub.layers.ImageConverter")
+class ImageConverter(PreprocessingLayer):
+    """Convert raw image for models that support image input.
+
+    This class converts from raw images of any size, to preprocessed
+    images for pretrained model inputs. It is meant to be a convenient way to
+    write custom preprocessing code that is not model specific. This layer
+    should be instantiated via the `from_preset()` constructor, which will
+    create the correct subclass of this layer for the model preset.
+
+    The layer will take as input a raw image tensor in the channels last or
+    channels first format, and output a preprocessed image input for modeling.
+    The exact structure of the output will vary per model, though in most cases
+    this layer will simply resize the image to the size needed by the model
+    input.
+
+    Examples:
+    ```python
+    # Resize images for `"pali_gemma_3b_224"`.
+    converter = keras_hub.layers.ImageConverter.from_preset("pali_gemma_3b_224")
+    converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 224, 224, 3)
+    # Resize images for `"pali_gemma_3b_448"`.
+    converter = keras_hub.layers.ImageConverter.from_preset("pali_gemma_3b_448")
+    converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 448, 448, 3)
+    ```
+    """
+
+    backbone_cls = None
+
+    def image_size(self):
+        """Returns the default size of a single image."""
+        return (None, None)
+
+    @classproperty
+    def presets(cls):
+        """List built-in presets for an `ImageConverter` subclass."""
+        return builtin_presets(cls)
+
+    @classmethod
+    def from_preset(
+        cls,
+        preset,
+        **kwargs,
+    ):
+        """Instantiate a `keras_hub.layers.ImageConverter` from a model preset.
+
+        A preset is a directory of configs, weights and other file assets used
+        to save and load a pre-trained model. The `preset` can be passed as
+        one of:
+
+        1. a built-in preset identifier like `'pali_gemma_3b_224'`
+        2. a Kaggle Models handle like
+           `'kaggle://user/paligemma/keras/pali_gemma_3b_224'`
+        3. a Hugging Face handle like `'hf://user/pali_gemma_3b_224'`
+        4. a path to a local preset directory like `'./pali_gemma_3b_224'`
+
+        You can run `cls.presets.keys()` to list all built-in presets available
+        on the class.
+
+        This constructor can be called in one of two ways. Either from the base
+        class like `keras_hub.models.ImageConverter.from_preset()`, or from a
+        model class like
+        `keras_hub.models.PaliGemmaImageConverter.from_preset()`. If calling
+        from the base class, the subclass of the returning object will be
+        inferred from the config in the preset directory.
+
+        Args:
+            preset: string. A built-in preset identifier, a Kaggle Models
+                handle, a Hugging Face handle, or a path to a local directory.
+            load_weights: bool. If `True`, the weights will be loaded into the
+                model architecture. If `False`, the weights will be randomly
+                initialized.
+
+        Examples:
+        ```python
+        # Resize images for `"pali_gemma_3b_224"`.
+        converter = keras_hub.layers.ImageConverter.from_preset(
+            "pali_gemma_3b_224"
+        )
+        converter(np.ones(2, 512, 512, 3)) # Output shape: (2, 224, 224, 3)
+        # Override arguments on the base class.
+        converter = keras_hub.layers.ImageConverter.from_preset(
+            "pali_gemma_3b_448",
+            crop_to_aspect_ratio=False,
+        )
+        converter(np.ones(2, 512, 512, 3)) # (2, 448, 448, 3)
+        ```
+        """
+        loader = get_preset_loader(preset)
+        backbone_cls = loader.check_backbone_class()
+        if cls.backbone_cls != backbone_cls:
+            cls = find_subclass(preset, cls, backbone_cls)
+        return loader.load_image_converter(cls, **kwargs)
+
+    def save_to_preset(self, preset_dir):
+        """Save image converter to a preset directory.
+
+        Args:
+            preset_dir: The path to the local model preset directory.
+        """
+        save_serialized_object(
+            self,
+            preset_dir,
+            config_file=IMAGE_CONVERTER_CONFIG_FILE,
+        )

keras_hub/src/layers/preprocessing/masked_lm_mask_generator.py

@@ -18,6 +18,7 @@ from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
 from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 try:
     import tensorflow as tf
@@ -165,6 +166,7 @@ class MaskedLMMaskGenerator(PreprocessingLayer):
             random_token_rate=self.random_token_rate,
         )
 
+    @preprocessing_function
     def call(self, inputs):
         inputs, unbatched, rectangular = convert_to_ragged_batch(inputs)
 

keras_hub/src/layers/preprocessing/multi_segment_packer.py

@@ -17,6 +17,7 @@ from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
 from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 try:
     import tensorflow as tf
@@ -193,23 +194,22 @@ class MultiSegmentPacker(PreprocessingLayer):
     def _sanitize_inputs(self, inputs):
         """Force inputs to a list of rank 2 ragged tensors."""
         # Sanitize inputs.
-        if not isinstance(inputs, (list, tuple)):
+        if not isinstance(inputs, tuple):
             inputs = (inputs,)
         if not inputs:
             raise ValueError(
                 "At least one input is required for packing. "
                 f"Received: `inputs={inputs}`"
             )
-        inputs, unbatched_list, _ = list(
-            zip(*(convert_to_ragged_batch(x) for x in inputs))
-        )
-        if len(set(unbatched_list)) != 1:
-            ranks = [1 if unbatched else 2 for unbatched in unbatched_list]
+        # convert_to_ragged_batch returns (x, unbatched, regtangular) triplets.
+        triplets = [convert_to_ragged_batch(x) for x in inputs]
+        x, unbatched, rectangular = list(zip(*triplets))
+        if len(set(unbatched)) != 1:
             raise ValueError(
                 "All inputs for packing must have the same rank. "
-                f"Received: `inputs={inputs}` with ranks {ranks}"
+                f"Received: `inputs={inputs}`."
             )
-        return inputs, unbatched_list[0]
+        return x, unbatched[0]
 
     def _trim_inputs(self, inputs):
         """Trim inputs to desired length."""
@@ -282,6 +282,7 @@ class MultiSegmentPacker(PreprocessingLayer):
         segment_ids = tf.concat(segment_ids_to_combine, 1)
         return token_ids, segment_ids
 
+    @preprocessing_function
     def call(
         self,
         inputs,

keras_hub/src/layers/preprocessing/preprocessing_layer.py

@@ -13,17 +13,8 @@
 # limitations under the License.
 
 import keras
-from keras import tree
 
 from keras_hub.src.utils.tensor_utils import assert_tf_libs_installed
-from keras_hub.src.utils.tensor_utils import (
-    convert_to_backend_tensor_or_python_list,
-)
-
-try:
-    import tensorflow as tf
-except ImportError:
-    tf = None
 
 
 class PreprocessingLayer(keras.layers.Layer):
@@ -31,9 +22,10 @@ class PreprocessingLayer(keras.layers.Layer):
 
     def __init__(self, **kwargs):
         assert_tf_libs_installed(self.__class__.__name__)
-
         super().__init__(**kwargs)
+        # Don't convert inputs (we want tf tensors not backend tensors).
         self._convert_input_args = False
+        # Allow raw inputs like python strings.
         self._allow_non_tensor_positional_args = True
         # Most pre-preprocessing has no build.
         if not hasattr(self, "build"):
@@ -41,22 +33,3 @@ class PreprocessingLayer(keras.layers.Layer):
 
     def get_build_config(self):
         return None
-
-    def __call__(self, *args, **kwargs):
-        # Always place on CPU for preprocessing, to avoid expensive back and
-        # forth copies to GPU before the trainable model.
-        with tf.device("cpu"):
-            outputs = super().__call__(*args, **kwargs)
-
-            # Jax and Torch lack native string and ragged types.
-            # If we are running on those backends and not running with tf.data
-            # (we are outside a tf.function), we covert all ragged and string
-            # tensor to pythonic types.
-            is_tf_backend = keras.config.backend() == "tensorflow"
-            is_in_tf_graph = not tf.executing_eagerly()
-            if not is_tf_backend and not is_in_tf_graph:
-                outputs = tree.map_structure(
-                    convert_to_backend_tensor_or_python_list, outputs
-                )
-
-        return outputs

keras_hub/src/layers/preprocessing/random_deletion.py

@@ -21,6 +21,7 @@ from keras_hub.src.layers.preprocessing.preprocessing_layer import (
 from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
 from keras_hub.src.utils.tensor_utils import is_int_dtype
 from keras_hub.src.utils.tensor_utils import is_string_dtype
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 try:
     import tensorflow as tf
@@ -65,55 +66,55 @@ class RandomDeletion(PreprocessingLayer):
 
     Word level usage.
     >>> keras.utils.set_random_seed(1337)
-    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
-    >>> augmenter=keras_hub.layers.RandomDeletion(rate=0.4, seed=42)
-    >>> augmented=augmenter(inputs)
-    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
-    <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'I like', b'and'],
-    dtype=object)>
+    >>> x = ["Hey I like", "Keras and Tensorflow"]
+    >>> x = list(map(lambda x: x.split(), x))
+    >>> augmenter = keras_hub.layers.RandomDeletion(rate=0.4, seed=42)
+    >>> y = augmenter(x)
+    >>> list(map(lambda y: " ".join(y), y))
+    ['I like', 'and']
 
     Character level usage.
     >>> keras.utils.set_random_seed(1337)
-    >>> inputs=tf.strings.unicode_split(["Hey Dude", "Speed Up"], "UTF-8")
-    >>> augmenter=keras_hub.layers.RandomDeletion(rate=0.4, seed=42)
-    >>> augmented=augmenter(inputs)
-    >>> tf.strings.reduce_join(augmented, axis=-1)
-    <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'H Dude', b'pedUp'],
-    dtype=object)>
+    >>> x = ["Hey Dude", "Speed Up"]
+    >>> x = list(map(lambda x: list(x), x))
+    >>> augmenter = keras_hub.layers.RandomDeletion(rate=0.4, seed=42)
+    >>> y = augmenter(x)
+    >>> list(map(lambda y: "".join(y), y))
+    ['H Dude', 'pedUp']
 
     Usage with skip_list.
     >>> keras.utils.set_random_seed(1337)
-    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
-    >>> augmenter=keras_hub.layers.RandomDeletion(rate=0.4,
+    >>> x = ["Hey I like", "Keras and Tensorflow"]
+    >>> x = list(map(lambda x: x.split(), x))
+    >>> augmenter = keras_hub.layers.RandomDeletion(rate=0.4,
     ...     skip_list=["Keras", "Tensorflow"], seed=42)
-    >>> augmented=augmenter(inputs)
-    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
-    <tf.Tensor: shape=(2,), dtype=string,
-    numpy=array([b'I like', b'Keras Tensorflow'], dtype=object)>
+    >>> y = augmenter(x)
+    >>> list(map(lambda y: " ".join(y), y))
+    ['I like', 'Keras Tensorflow']
 
     Usage with skip_fn.
     >>> def skip_fn(word):
     ...     return tf.strings.regex_full_match(word, r"\\pP")
     >>> keras.utils.set_random_seed(1337)
-    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
-    >>> augmenter=keras_hub.layers.RandomDeletion(rate=0.4,
+    >>> x = ["Hey I like", "Keras and Tensorflow"]
+    >>> x = list(map(lambda x: x.split(), x))
+    >>> augmenter = keras_hub.layers.RandomDeletion(rate=0.4,
     ...     skip_fn=skip_fn, seed=42)
-    >>> augmented=augmenter(inputs)
-    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
-    <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'I like', b'and'],
-    dtype=object)>
+    >>> y = augmenter(x)
+    >>> list(map(lambda y: " ".join(y), y))
+    ['I like', 'and']
 
     Usage with skip_py_fn.
     >>> def skip_py_fn(word):
     ...     return len(word) < 4
     >>> keras.utils.set_random_seed(1337)
-    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
-    >>> augmenter=RandomDeletion(rate=0.4,
+    >>> x = ["Hey I like", "Keras and Tensorflow"]
+    >>> x = list(map(lambda x: x.split(), x))
+    >>> augmenter = RandomDeletion(rate=0.4,
     ...     skip_py_fn=skip_py_fn, seed=42)
-    >>> augmented=augmenter(inputs)
-    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
-    <tf.Tensor: shape=(2,), dtype=string,
-    numpy=array([b'Hey I', b'and Tensorflow'], dtype=object)>
+    >>> y = augmenter(x)
+    >>> list(map(lambda y: " ".join(y), y))
+    ['Hey I', 'and Tensorflow']
     """
 
     def __init__(
@@ -170,8 +171,9 @@ class RandomDeletion(PreprocessingLayer):
                 default_value=False,
             )
 
+    @preprocessing_function
     def call(self, inputs):
-        inputs, unbatched, _ = convert_to_ragged_batch(inputs)
+        inputs, unbatched, rectangular = convert_to_ragged_batch(inputs)
 
         skip_masks = None
         if self.skip_list: