keras-hub 0.19.3__tar.gz → 0.20.0.dev0__tar.gz

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: keras-hub
-Version: 0.19.3
+Version: 0.20.0.dev0
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/keras_hub/api/layers/__init__.py

@@ -42,6 +42,9 @@ from keras_hub.src.models.basnet.basnet_image_converter import (
     BASNetImageConverter,
 )
 from keras_hub.src.models.clip.clip_image_converter import CLIPImageConverter
+from keras_hub.src.models.cspnet.cspnet_image_converter import (
+    CSPNetImageConverter,
+)
 from keras_hub.src.models.deeplab_v3.deeplab_v3_image_converter import (
     DeepLabV3ImageConverter,
 )
@@ -73,6 +76,9 @@ from keras_hub.src.models.sam.sam_prompt_encoder import SAMPromptEncoder
 from keras_hub.src.models.segformer.segformer_image_converter import (
     SegFormerImageConverter,
 )
+from keras_hub.src.models.siglip.siglip_image_converter import (
+    SigLIPImageConverter,
+)
 from keras_hub.src.models.vgg.vgg_image_converter import VGGImageConverter
 from keras_hub.src.models.vit.vit_image_converter import ViTImageConverter
 from keras_hub.src.models.whisper.whisper_audio_converter import (

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/keras_hub/api/models/__init__.py

@@ -61,11 +61,12 @@ from keras_hub.src.models.clip.clip_preprocessor import CLIPPreprocessor
 from keras_hub.src.models.clip.clip_text_encoder import CLIPTextEncoder
 from keras_hub.src.models.clip.clip_tokenizer import CLIPTokenizer
 from keras_hub.src.models.clip.clip_vision_encoder import CLIPVisionEncoder
-from keras_hub.src.models.csp_darknet.csp_darknet_backbone import (
-    CSPDarkNetBackbone,
+from keras_hub.src.models.cspnet.cspnet_backbone import CSPNetBackbone
+from keras_hub.src.models.cspnet.cspnet_image_classifier import (
+    CSPNetImageClassifier,
 )
-from keras_hub.src.models.csp_darknet.csp_darknet_image_classifier import (
-    CSPDarkNetImageClassifier,
+from keras_hub.src.models.cspnet.cspnet_image_classifier_preprocessor import (
+    CSPNetImageClassifierPreprocessor,
 )
 from keras_hub.src.models.deberta_v3.deberta_v3_backbone import (
     DebertaV3Backbone,
@@ -182,6 +183,9 @@ from keras_hub.src.models.gemma3.gemma3_causal_lm_preprocessor import (
     Gemma3CausalLMPreprocessor,
 )
 from keras_hub.src.models.gemma3.gemma3_tokenizer import Gemma3Tokenizer
+from keras_hub.src.models.gemma3.gemma3_vision_encoder import (
+    Gemma3VisionEncoder,
+)
 from keras_hub.src.models.gpt2.gpt2_backbone import GPT2Backbone
 from keras_hub.src.models.gpt2.gpt2_causal_lm import GPT2CausalLM
 from keras_hub.src.models.gpt2.gpt2_causal_lm_preprocessor import (
@@ -304,6 +308,24 @@ from keras_hub.src.models.roberta.roberta_text_classifier_preprocessor import (
     RobertaTextClassifierPreprocessor as RobertaPreprocessor,
 )
 from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
+from keras_hub.src.models.roformer_v2.roformer_v2_backbone import (
+    RoformerV2Backbone as RorformerV2Backbone,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_masked_lm import (
+    RoformerV2MaskedLM,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_masked_lm_preprocessor import (
+    RoformerV2MaskedLMPreprocessor,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_text_classifier import (
+    RorformerV2TextClassifier,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_text_classifier_preprocessor import (
+    RoformerV2TextClassifierPreprocessor,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
+    RoformerV2Tokenizer,
+)
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 from keras_hub.src.models.sam.sam_image_segmenter import SAMImageSegmenter
 from keras_hub.src.models.sam.sam_image_segmenter_preprocessor import (
@@ -318,6 +340,13 @@ from keras_hub.src.models.segformer.segformer_image_segmenter_preprocessor impor
 )
 from keras_hub.src.models.seq_2_seq_lm import Seq2SeqLM
 from keras_hub.src.models.seq_2_seq_lm_preprocessor import Seq2SeqLMPreprocessor
+from keras_hub.src.models.siglip.siglip_backbone import SigLIPBackbone
+from keras_hub.src.models.siglip.siglip_preprocessor import SigLIPPreprocessor
+from keras_hub.src.models.siglip.siglip_text_encoder import SigLIPTextEncoder
+from keras_hub.src.models.siglip.siglip_tokenizer import SigLIPTokenizer
+from keras_hub.src.models.siglip.siglip_vision_encoder import (
+    SigLIPVisionEncoder,
+)
 from keras_hub.src.models.stable_diffusion_3.stable_diffusion_3_backbone import (
     StableDiffusion3Backbone,
 )
@@ -343,6 +372,9 @@ from keras_hub.src.models.text_classifier_preprocessor import (
     TextClassifierPreprocessor,
 )
 from keras_hub.src.models.text_to_image import TextToImage
+from keras_hub.src.models.text_to_image_preprocessor import (
+    TextToImagePreprocessor,
+)
 from keras_hub.src.models.vgg.vgg_backbone import VGGBackbone
 from keras_hub.src.models.vgg.vgg_image_classifier import VGGImageClassifier
 from keras_hub.src.models.vgg.vgg_image_classifier_preprocessor import (

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/keras_hub/api/tokenizers/__init__.py

@@ -31,6 +31,10 @@ from keras_hub.src.models.pali_gemma.pali_gemma_tokenizer import (
 )
 from keras_hub.src.models.phi3.phi3_tokenizer import Phi3Tokenizer
 from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
+from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
+    RoformerV2Tokenizer,
+)
+from keras_hub.src.models.siglip.siglip_tokenizer import SigLIPTokenizer
 from keras_hub.src.models.t5.t5_tokenizer import T5Tokenizer
 from keras_hub.src.models.whisper.whisper_tokenizer import WhisperTokenizer
 from keras_hub.src.models.xlm_roberta.xlm_roberta_tokenizer import (

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/keras_hub/src/layers/preprocessing/image_converter.py

@@ -1,6 +1,7 @@
 import math
 
 import keras
+import ml_dtypes
 import numpy as np
 from keras import ops
 
@@ -15,9 +16,99 @@ from keras_hub.src.utils.preset_utils import get_preset_loader
 from keras_hub.src.utils.preset_utils import get_preset_saver
 from keras_hub.src.utils.python_utils import classproperty
 from keras_hub.src.utils.tensor_utils import check_bounding_box_support
+from keras_hub.src.utils.tensor_utils import in_tf_function
 from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
+# TODO: Use `keras.layers.Resizing` once `antialias` is configurable.
+# https://github.com/keras-team/keras/pull/20972
+def _saturate_cast(x, dtype, backend_module):
+    def get_dtype_min_max(dtype):
+        if "bool" == dtype:
+            dtype_min = 0
+            dtype_max = 1
+        elif "int" in dtype:
+            dtype_min = ml_dtypes.iinfo(dtype).min
+            dtype_max = ml_dtypes.iinfo(dtype).max
+        else:
+            dtype_min = ml_dtypes.finfo(dtype).min
+            dtype_max = ml_dtypes.finfo(dtype).max
+        return dtype_min, dtype_max
+
+    dtype = keras.backend.standardize_dtype(dtype)
+    in_dtype = keras.backend.standardize_dtype(x.dtype)
+    in_min, in_max = get_dtype_min_max(in_dtype)
+    out_min, out_max = get_dtype_min_max(dtype)
+
+    min_limit = np.maximum(in_min, out_min).astype(in_dtype)
+    if min_limit < out_min:
+        min_limit = np.nextafter(min_limit, 0, dtype=in_dtype)
+    max_limit = np.minimum(in_max, out_max).astype(in_dtype)
+    if max_limit > out_max:
+        max_limit = np.nextafter(max_limit, 0, dtype=in_dtype)
+
+    x = backend_module.numpy.clip(x, min_limit, max_limit)
+    return backend_module.cast(x, dtype)
+
+
+class ResizingAntialiasConfigurable(keras.layers.Resizing):
+    """A preprocessing layer which resizes images.
+
+    This class is the same as `keras.layers.Resizing` but exposes `antialias` as
+    a configurable parameter.
+    """
+
+    def __init__(
+        self,
+        height,
+        width,
+        interpolation="bilinear",
+        antialias=False,
+        crop_to_aspect_ratio=False,
+        pad_to_aspect_ratio=False,
+        fill_mode="constant",
+        fill_value=0.0,
+        data_format=None,
+        **kwargs,
+    ):
+        super().__init__(
+            height=height,
+            width=width,
+            interpolation=interpolation,
+            crop_to_aspect_ratio=crop_to_aspect_ratio,
+            pad_to_aspect_ratio=pad_to_aspect_ratio,
+            fill_mode=fill_mode,
+            fill_value=fill_value,
+            data_format=data_format,
+            **kwargs,
+        )
+        self.antialias = bool(antialias)
+
+    def transform_images(self, images, transformation=None, training=True):
+        size = (self.height, self.width)
+        resized = self.backend.image.resize(
+            images,
+            size=size,
+            interpolation=self.interpolation,
+            antialias=self.antialias,  # Added.
+            data_format=self.data_format,
+            crop_to_aspect_ratio=self.crop_to_aspect_ratio,
+            pad_to_aspect_ratio=self.pad_to_aspect_ratio,
+            fill_mode=self.fill_mode,
+            fill_value=self.fill_value,
+        )
+        if resized.dtype == images.dtype:
+            return resized
+        if keras.backend.is_int_dtype(images.dtype):
+            resized = self.backend.numpy.round(resized)
+        return _saturate_cast(resized, images.dtype, self.backend)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update({"antialias": self.antialias})
+        return config
+
+
 @keras_hub_export("keras_hub.layers.ImageConverter")
 class ImageConverter(PreprocessingLayer):
     """Preprocess raw images into model ready inputs.
@@ -65,6 +156,8 @@ class ImageConverter(PreprocessingLayer):
         interpolation: String, the interpolation method.
             Supports `"bilinear"`, `"nearest"`, `"bicubic"`,
             `"lanczos3"`, `"lanczos5"`. Defaults to `"bilinear"`.
+        antialias: Whether to use an antialiasing filter when downsampling an
+            image. Defaults to `False`.
         bounding_box_format: A string specifying the format of the bounding
             boxes, one of `"xyxy"`, `"rel_xyxy"`, `"xywh"`, `"center_xywh"`,
             `"yxyx"`, `"rel_yxyx"`. Specifies the format of the bounding boxes
@@ -107,6 +200,7 @@ class ImageConverter(PreprocessingLayer):
         crop_to_aspect_ratio=True,
         pad_to_aspect_ratio=False,
         interpolation="bilinear",
+        antialias=False,
         bounding_box_format="yxyx",
         data_format=None,
         **kwargs,
@@ -132,12 +226,13 @@ class ImageConverter(PreprocessingLayer):
         resizing_kwargs = {}
         if check_bounding_box_support():
             resizing_kwargs["bounding_box_format"] = bounding_box_format
-        self.resizing = keras.layers.Resizing(
+        self.resizing = ResizingAntialiasConfigurable(
             height=image_size[0] if image_size else None,
             width=image_size[1] if image_size else None,
             crop_to_aspect_ratio=crop_to_aspect_ratio,
             pad_to_aspect_ratio=pad_to_aspect_ratio,
             interpolation=interpolation,
+            antialias=antialias,
             data_format=data_format,
             dtype=self.dtype_policy,
             name="resizing",
@@ -148,6 +243,7 @@ class ImageConverter(PreprocessingLayer):
         self.crop_to_aspect_ratio = crop_to_aspect_ratio
         self.pad_to_aspect_ratio = pad_to_aspect_ratio
         self.interpolation = interpolation
+        self.antialias = antialias
         self.bounding_box_format = bounding_box_format
         self.data_format = standardize_data_format(data_format)
 
@@ -175,9 +271,15 @@ class ImageConverter(PreprocessingLayer):
         else:
             x = inputs
         if self.scale is not None:
-            x = x * self._expand_non_channel_dims(self.scale, x)
+            # If we are scaling always cast to the compute dtype. We can't
+            # leave things as an int type if we are scaling to [0, 1].
+            scale = self._expand_non_channel_dims(self.scale, x)
+            x, scale = self._convert_types(x, scale, self.compute_dtype)
+            x = x * scale
         if self.offset is not None:
-            x = x + self._expand_non_channel_dims(self.offset, x)
+            offset = self._expand_non_channel_dims(self.offset, x)
+            x, offset = self._convert_types(x, offset, x.dtype)
+            x = x + offset
         if isinstance(inputs, dict):
             inputs["images"] = x
         else:
@@ -185,23 +287,29 @@ class ImageConverter(PreprocessingLayer):
         return inputs
 
     def _expand_non_channel_dims(self, value, inputs):
+        """Expand non channel dims so value is broadcastable with inputs."""
         unbatched = len(ops.shape(inputs)) == 3
         channels_first = self.data_format == "channels_first"
         if unbatched:
             broadcast_dims = (1, 2) if channels_first else (0, 1)
         else:
             broadcast_dims = (0, 2, 3) if channels_first else (0, 1, 2)
-        # If inputs are not a tensor type, return a numpy array.
-        # This might happen when running under tf.data.
-        if ops.is_tensor(inputs):
-            # preprocessing decorator moves tensors to cpu in torch backend and
-            # processed on CPU, and then converted back to the appropriate
-            # device (potentially GPU) after preprocessing.
-            if keras.backend.backend() == "torch" and self.image_size is None:
-                return ops.expand_dims(value, broadcast_dims).cpu()
-            return ops.expand_dims(value, broadcast_dims)
-        else:
-            return np.expand_dims(value, broadcast_dims)
+        # An numpy value will work backend native ops or with tf.data.
+        return np.expand_dims(value, broadcast_dims)
+
+    def _convert_types(self, x, y, dtype):
+        """Make sure x and y have the same dtype and are on ths same device."""
+        if in_tf_function():
+            # This could happen on any backend if we are running in tf.data.
+            import tensorflow as tf
+
+            return tf.cast(x, dtype), tf.cast(y, dtype)
+        x = ops.cast(x, dtype)
+        y = ops.cast(y, dtype)
+        if keras.backend.backend() == "torch":
+            # Place on the same device as x (the image).
+            y = y.to(x.device)
+        return x, y
 
     def get_config(self):
         config = super().get_config()
@@ -211,6 +319,7 @@ class ImageConverter(PreprocessingLayer):
                 "scale": self.scale,
                 "offset": self.offset,
                 "interpolation": self.interpolation,
+                "antialias": self.antialias,
                 "crop_to_aspect_ratio": self.crop_to_aspect_ratio,
                 "pad_to_aspect_ratio": self.pad_to_aspect_ratio,
                 "bounding_box_format": self.bounding_box_format,

{keras_hub-0.19.3 → keras_hub-0.20.0.dev0}/keras_hub/src/models/backbone.py

@@ -194,15 +194,15 @@ class Backbone(keras.Model):
         """
         return ["query_dense", "value_dense", "query", "value"]
 
-    def enable_lora(self, rank):
+    def enable_lora(self, rank, target_names=None):
         """Enable Lora on the backbone.
 
         Calling this method will freeze all weights on the backbone,
         while enabling Lora on the query & value `EinsumDense` layers
         of the attention layers.
         """
-        target_names = self.get_lora_target_names()
-
+        if target_names is None:
+            target_names = self.get_lora_target_names()
         self.trainable = True
         self._lora_enabled_layers = []
         self._lora_rank = rank

keras_hub-0.20.0.dev0/keras_hub/src/models/cspnet/__init__.py

@@ -0,0 +1,5 @@
+from keras_hub.src.models.cspnet.cspnet_backbone import CSPNetBackbone
+from keras_hub.src.models.cspnet.cspnet_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, CSPNetBackbone)