keras-hub-nightly 0.16.1.dev202410020340__py3-none-any.whl → 0.16.1.dev202410040340__py3-none-any.whl

keras_hub/src/models/image_segmenter.py

@@ -16,11 +16,6 @@ class ImageSegmenter(Task):
     be used to load a pre-trained config and weights.
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-        # Default compilation.
-        self.compile()
-
     def compile(
         self,
         optimizer="auto",

keras_hub/src/models/image_segmenter_preprocessor.py

@@ -19,9 +19,11 @@ class ImageSegmenterPreprocessor(Preprocessor):
 
     - `x`: The first input, should always be included. It can be an image or
       a batch of images.
-    - `y`: (Optional) Usually the segmentation mask(s), will be passed through
-      unaltered.
+    - `y`: (Optional) Usually the segmentation mask(s), if `resize_output_mask`
+        is set to `True` this will be resized to input image shape else will be
+        passed through unaltered.
     - `sample_weight`: (Optional) Will be passed through unaltered.
+    - `resize_output_mask` bool: If set to `True` the output mask will be resized to the same size as the input image. Defaults to `False`.
 
     The layer will output either `x`, an `(x, y)` tuple if labels were provided,
     or an `(x, y, sample_weight)` tuple if labels and sample weight were
@@ -29,7 +31,7 @@ class ImageSegmenterPreprocessor(Preprocessor):
     been applied.
 
     All `ImageSegmenterPreprocessor` tasks include a `from_preset()`
-    constructor which can be used to load a pre-trained config and vocabularies.
+    constructor which can be used to load a pre-trained config.
     You can call the `from_preset()` constructor directly on this base class, in
     which case the correct class for your model will be automatically
     instantiated.
@@ -49,7 +51,8 @@ class ImageSegmenterPreprocessor(Preprocessor):
     x, y = preprocessor(x, y)
 
     # Resize a batch of images and masks.
-    x, y = [np.ones((512, 512, 3)), np.zeros((512, 512, 3))], [np.ones((512, 512, 1)), np.zeros((512, 512, 1))]
+    x, y = [np.ones((512, 512, 3)), np.zeros((512, 512, 3))],
+           [np.ones((512, 512, 1)), np.zeros((512, 512, 1))]
     x, y = preprocessor(x, y)
 
     # Use a `tf.data.Dataset`.
@@ -61,13 +64,35 @@ class ImageSegmenterPreprocessor(Preprocessor):
     def __init__(
         self,
         image_converter=None,
+        resize_output_mask=False,
         **kwargs,
     ):
         super().__init__(**kwargs)
         self.image_converter = image_converter
+        self.resize_output_mask = resize_output_mask
 
     @preprocessing_function
     def call(self, x, y=None, sample_weight=None):
         if self.image_converter:
             x = self.image_converter(x)
+
+        if y is not None and self.image_converter and self.resize_output_mask:
+
+            y = keras.layers.Resizing(
+                height=(
+                    self.image_converter.image_size[0]
+                    if self.image_converter.image_size
+                    else None
+                ),
+                width=(
+                    self.image_converter.image_size[1]
+                    if self.image_converter.image_size
+                    else None
+                ),
+                crop_to_aspect_ratio=self.image_converter.crop_to_aspect_ratio,
+                interpolation="nearest",
+                data_format=self.image_converter.data_format,
+                dtype=self.dtype_policy,
+                name="mask_resizing",
+            )(y)
         return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)

keras_hub/src/models/mix_transformer/mix_transformer_classifier.py

@@ -1,5 +1,3 @@
-import keras
-
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.mix_transformer.mix_transformer_backbone import (
@@ -9,111 +7,4 @@ from keras_hub.src.models.mix_transformer.mix_transformer_backbone import (
 
 @keras_hub_export("keras_hub.models.MiTImageClassifier")
 class MiTImageClassifier(ImageClassifier):
-    """MiTImageClassifier image classifier model.
-
-    Args:
-        backbone: A `keras_hub.models.MiTBackbone` instance.
-        num_classes: int. The number of classes to predict.
-        activation: `None`, str or callable. The activation function to use on
-            the `Dense` layer. Set `activation=None` to return the output
-            logits. Defaults to `"softmax"`.
-
-    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
-    where `x` is a tensor and `y` is a integer from `[0, num_classes)`.
-    All `ImageClassifier` tasks include a `from_preset()` constructor which can
-    be used to load a pre-trained config and weights.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.MiTImageClassifier.from_preset(
-        "mit_b0_imagenet")
-    classifier.predict(images)
-    ```
-
-    Call `fit()` on a single batch.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    classifier = keras_hub.models.MixTransformerImageClassifier.from_preset(
-        "mit_b0_imagenet")
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Call `fit()` with custom loss, optimizer and backbone.
-    ```python
-    classifier = keras_hub.models.MiTImageClassifier.from_preset(
-        "mit_b0_imagenet")
-    classifier.compile(
-        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
-        optimizer=keras.optimizers.Adam(5e-5),
-    )
-    classifier.backbone.trainable = False
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Custom backbone.
-    ```python
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    backbone = keras_hub.models.MiTBackbone(
-        stackwise_num_filters=[128, 256, 512, 1024],
-        stackwise_depth=[3, 9, 9, 3],
-        block_type="basic_block",
-        image_shape = (224, 224, 3),
-    )
-    classifier = keras_hub.models.MiTImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = MiTBackbone
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        activation="softmax",
-        preprocessor=None,  # adding this dummy arg for saved model test
-        # TODO: once preprocessor flow is figured out, this needs to be updated
-        **kwargs,
-    ):
-        # === Layers ===
-        self.backbone = backbone
-        self.output_dense = keras.layers.Dense(
-            num_classes,
-            activation=activation,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/mobilenet/mobilenet_image_classifier.py

@@ -1,5 +1,3 @@
-import keras
-
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
@@ -7,94 +5,4 @@ from keras_hub.src.models.mobilenet.mobilenet_backbone import MobileNetBackbone
 
 @keras_hub_export("keras_hub.models.MobileNetImageClassifier")
 class MobileNetImageClassifier(ImageClassifier):
-    """MobileNetV3 image classifier task model.
-
-    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
-    where `x` is a tensor and `y` is a integer from `[0, num_classes)`.
-    All `ImageClassifier` tasks include a `from_preset()` constructor which can
-    be used to load a pre-trained config and weights.
-
-    Args:
-        backbone: A `keras_hub.models.MobileNetBackbone` instance.
-        num_classes: int. The number of classes to predict.
-        activation: `None`, str or callable. The activation function to use on
-            the `Dense` layer. Set `activation=None` to return the output
-            logits. Defaults to `"softmax"`.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.MobileNetImageClassifier.from_preset(
-        "mobilenet_v3_small_imagenet")
-    classifier.predict(images)
-    ```
-
-    Custom backbone.
-    ```python
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    model = MobileNetBackbone(
-        stackwise_expansion = [1, 4, 6],
-        stackwise_filters = [4, 8, 16],
-        stackwise_kernel_size = [3, 3, 5],
-        stackwise_stride = [2, 2, 1],
-        stackwise_se_ratio = [ 0.25, None, 0.25],
-        stackwise_activation = ["relu", "relu", "hard_swish"],
-        output_filter=1280,
-        activation="hard_swish",
-        inverted_res_block=True,
-    )
-    classifier = keras_hub.models.MobileNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = MobileNetBackbone
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        activation="softmax",
-        preprocessor=None,  # adding this dummy arg for saved model test
-        # TODO: once preprocessor flow is figured out, this needs to be updated
-        **kwargs,
-    ):
-        # === Layers ===
-        self.backbone = backbone
-        self.output_dense = keras.layers.Dense(
-            num_classes,
-            activation=activation,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/pali_gemma/pali_gemma_image_converter.py

@@ -1,12 +1,10 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
+from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.pali_gemma.pali_gemma_backbone import (
     PaliGemmaBackbone,
 )
 
 
 @keras_hub_export("keras_hub.layers.PaliGemmaImageConverter")
-class PaliGemmaImageConverter(ResizingImageConverter):
+class PaliGemmaImageConverter(ImageConverter):
     backbone_cls = PaliGemmaBackbone

keras_hub/src/models/preprocessor.py

@@ -8,7 +8,7 @@ from keras_hub.src.utils.preset_utils import PREPROCESSOR_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.preset_utils import get_preset_saver
 from keras_hub.src.utils.python_utils import classproperty
 
 
@@ -209,7 +209,5 @@ class Preprocessor(PreprocessingLayer):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(self, preset_dir, config_file=self.config_name)
-        for layer in self._flatten_layers(include_self=False):
-            if hasattr(layer, "save_to_preset"):
-                layer.save_to_preset(preset_dir)
+        saver = get_preset_saver(preset_dir)
+        saver.save_preprocessor(self)

keras_hub/src/models/resnet/resnet_backbone.py

@@ -51,16 +51,6 @@ class ResNetBackbone(FeaturePyramidBackbone):
             `True` for ResNetV2, `False` for ResNet.
         image_shape: tuple. The input shape without the batch size.
             Defaults to `(None, None, 3)`.
-        pooling: `None` or str. Pooling mode for feature extraction. Defaults
-            to `"avg"`.
-            - `None` means that the output of the model will be the 4D tensor
-                from the last convolutional block.
-            - `avg` means that global average pooling will be applied to the
-                output of the last convolutional block, resulting in a 2D
-                tensor.
-            - `max` means that global max pooling will be applied to the
-                output of the last convolutional block, resulting in a 2D
-                tensor.
         data_format: `None` or str. If specified, either `"channels_last"` or
             `"channels_first"`. The ordering of the dimensions in the
             inputs. `"channels_last"` corresponds to inputs with shape
@@ -75,7 +65,7 @@ class ResNetBackbone(FeaturePyramidBackbone):
 
     Examples:
     ```python
-    input_data = np.random.uniform(0, 255, size=(2, 224, 224, 3))
+    input_data = np.random.uniform(0, 1, size=(2, 224, 224, 3))
 
     # Pretrained ResNet backbone.
     model = keras_hub.models.ResNetBackbone.from_preset("resnet50")

keras_hub/src/models/resnet/resnet_image_classifier.py

@@ -1,5 +1,3 @@
-import keras
-
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
@@ -10,140 +8,5 @@ from keras_hub.src.models.resnet.resnet_image_classifier_preprocessor import (
 
 @keras_hub_export("keras_hub.models.ResNetImageClassifier")
 class ResNetImageClassifier(ImageClassifier):
-    """ResNet image classifier task model.
-
-    Args:
-        backbone: A `keras_hub.models.ResNetBackbone` instance.
-        num_classes: int. The number of classes to predict.
-        activation: `None`, str or callable. The activation function to use on
-            the `Dense` layer. Set `activation=None` to return the output
-            logits. Defaults to `"softmax"`.
-        head_dtype: `None` or str or `keras.mixed_precision.DTypePolicy`. The
-            dtype to use for the classification head's computations and weights.
-
-    To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
-    where `x` is a tensor and `y` is a integer from `[0, num_classes)`.
-    All `ImageClassifier` tasks include a `from_preset()` constructor which can
-    be used to load a pre-trained config and weights.
-
-    Examples:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
-        "resnet_50_imagenet"
-    )
-    classifier.predict(images)
-    ```
-
-    Call `fit()` on a single batch.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
-        "resnet_50_imagenet"
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Call `fit()` with custom loss, optimizer and backbone.
-    ```python
-    classifier = keras_hub.models.ResNetImageClassifier.from_preset(
-        "resnet_50_imagenet"
-    )
-    classifier.compile(
-        loss=keras.losses.SparseCategoricalCrossentropy(from_logits=True),
-        optimizer=keras.optimizers.Adam(5e-5),
-    )
-    classifier.backbone.trainable = False
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Custom backbone.
-    ```python
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    labels = [0, 3]
-    backbone = keras_hub.models.ResNetBackbone(
-        stackwise_num_filters=[64, 64, 64],
-        stackwise_num_blocks=[2, 2, 2],
-        stackwise_num_strides=[1, 2, 2],
-        block_type="basic_block",
-        use_pre_activation=True,
-        pooling="avg",
-    )
-    classifier = keras_hub.models.ResNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = ResNetBackbone
     preprocessor_cls = ResNetImageClassifierPreprocessor
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        preprocessor=None,
-        pooling="avg",
-        activation=None,
-        head_dtype=None,
-        **kwargs,
-    ):
-        head_dtype = head_dtype or backbone.dtype_policy
-
-        # === Layers ===
-        self.backbone = backbone
-        self.preprocessor = preprocessor
-        if pooling == "avg":
-            self.pooler = keras.layers.GlobalAveragePooling2D(
-                data_format=backbone.data_format, dtype=head_dtype
-            )
-        elif pooling == "max":
-            self.pooler = keras.layers.GlobalAveragePooling2D(
-                data_format=backbone.data_format, dtype=head_dtype
-            )
-        else:
-            raise ValueError(
-                "Unknown `pooling` type. Polling should be either `'avg'` or "
-                f"`'max'`. Received: pooling={pooling}."
-            )
-        self.output_dense = keras.layers.Dense(
-            num_classes,
-            activation=activation,
-            dtype=head_dtype,
-            name="predictions",
-        )
-
-        # === Functional Model ===
-        inputs = self.backbone.input
-        x = self.backbone(inputs)
-        x = self.pooler(x)
-        outputs = self.output_dense(x)
-        super().__init__(
-            inputs=inputs,
-            outputs=outputs,
-            **kwargs,
-        )
-
-        # === Config ===
-        self.num_classes = num_classes
-        self.activation = activation
-        self.pooling = pooling
-
-    def get_config(self):
-        # Backbone serialized in `super`
-        config = super().get_config()
-        config.update(
-            {
-                "num_classes": self.num_classes,
-                "pooling": self.pooling,
-                "activation": self.activation,
-            }
-        )
-        return config

keras_hub/src/models/resnet/resnet_image_converter.py

@@ -1,10 +1,8 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
+from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.resnet.resnet_backbone import ResNetBackbone
 
 
 @keras_hub_export("keras_hub.layers.ResNetImageConverter")
-class ResNetImageConverter(ResizingImageConverter):
+class ResNetImageConverter(ImageConverter):
     backbone_cls = ResNetBackbone

keras_hub/src/models/sam/__init__.py

@@ -0,0 +1,5 @@
+from keras_hub.src.models.sam.sam_backbone import SAMBackbone
+from keras_hub.src.models.sam.sam_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, SAMBackbone)

keras_hub/src/models/sam/sam_image_converter.py

@@ -1,10 +1,8 @@
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
+from keras_hub.src.layers.preprocessing.image_converter import ImageConverter
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 
 
 @keras_hub_export("keras_hub.layers.SAMImageConverter")
-class SAMImageConverter(ResizingImageConverter):
+class SAMImageConverter(ImageConverter):
     backbone_cls = SAMBackbone

keras_hub/src/models/sam/sam_image_segmenter_preprocessor.py

@@ -1,12 +1,22 @@
+import keras
+
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.image_segmenter_preprocessor import (
     ImageSegmenterPreprocessor,
 )
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 from keras_hub.src.models.sam.sam_image_converter import SAMImageConverter
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
-@keras_hub_export("keras_hub.models.SamImageSegmenterPreprocessor")
+@keras_hub_export("keras_hub.models.SAMImageSegmenterPreprocessor")
 class SAMImageSegmenterPreprocessor(ImageSegmenterPreprocessor):
     backbone_cls = SAMBackbone
     image_converter_cls = SAMImageConverter
+
+    @preprocessing_function
+    def call(self, x, y=None, sample_weight=None):
+        images = x["images"]
+        if self.image_converter:
+            x["images"] = self.image_converter(images)
+        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)

keras_hub/src/models/sam/sam_presets.py

@@ -9,7 +9,7 @@ backbone_presets = {
             "path": "sam",
             "model_card": "https://arxiv.org/abs/2304.02643",
         },
-        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_base_sa1b/1",
+        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_base_sa1b/2",
     },
     "sam_large_sa1b": {
         "metadata": {
@@ -19,7 +19,7 @@ backbone_presets = {
             "path": "sam",
             "model_card": "https://arxiv.org/abs/2304.02643",
         },
-        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_large_sa1b/1",
+        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_large_sa1b/2",
     },
     "sam_huge_sa1b": {
         "metadata": {
@@ -29,6 +29,6 @@ backbone_presets = {
             "path": "sam",
             "model_card": "https://arxiv.org/abs/2304.02643",
         },
-        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_huge_sa1b/1",
+        "kaggle_handle": "kaggle://kerashub/sam/keras/sam_huge_sa1b/2",
     },
 }

keras_hub/src/models/stable_diffusion_3/flow_match_euler_discrete_scheduler.py

@@ -27,7 +27,7 @@ class FlowMatchEulerDiscreteScheduler(layers.Layer):
     https://arxiv.org/abs/2403.03206).
     """
 
-    def __init__(self, num_train_timesteps=1000, shift=1.0, **kwargs):
+    def __init__(self, num_train_timesteps=1000, shift=3.0, **kwargs):
         super().__init__(**kwargs)
         self.num_train_timesteps = int(num_train_timesteps)
         self.shift = float(shift)
@@ -65,6 +65,13 @@ class FlowMatchEulerDiscreteScheduler(layers.Layer):
         timestep = self._sigma_to_timestep(sigma)
         return sigma, timestep
 
+    def add_noise(self, inputs, noises, step, num_steps):
+        sigma, _ = self(step, num_steps)
+        return ops.add(
+            ops.multiply(sigma, noises),
+            ops.multiply(ops.subtract(1.0, sigma), inputs),
+        )
+
     def get_config(self):
         config = super().get_config()
         config.update(