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

keras_hub/src/models/image_classifier.py

@@ -15,11 +15,156 @@ class ImageClassifier(Task):
 
     To fine-tune with `fit()`, pass a dataset containing tuples of `(x, y)`
     labels where `x` is a string 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.
 
-    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.Backbone` instance or a `keras.Model`.
+        num_classes: int. The number of classes to predict.
+        preprocessor: `None`, a `keras_hub.models.Preprocessor` instance,
+            a `keras.Layer` instance, or a callable. If `None` no preprocessing
+            will be applied to the inputs.
+        pooling: `"avg"` or `"max"`. The type of pooling to apply on backbone
+            output. Defaults to average pooling.
+        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`, str, or `keras.mixed_precision.DTypePolicy`. The
+            dtype to use for the classification head's computations and weights.
+
+    Examples:
+
+    Call `predict()` to run inference.
+    ```python
+    # Load preset and train
+    images = np.random.randint(0, 256, size=(2, 224, 224, 3))
+    classifier = keras_hub.models.ImageClassifier.from_preset(
+        "resnet_50_imagenet"
+    )
+    classifier.predict(images)
+    ```
+
+    Call `fit()` on a single batch.
+    ```python
+    # Load preset and train
+    images = np.random.randint(0, 256, size=(2, 224, 224, 3))
+    labels = [0, 3]
+    classifier = keras_hub.models.ImageClassifier.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.ImageClassifier.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.random.randint(0, 256, size=(2, 224, 224, 3))
+    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.ImageClassifier(
+        backbone=backbone,
+        num_classes=4,
+    )
+    classifier.fit(x=images, y=labels, batch_size=2)
+    ```
     """
 
+    def __init__(
+        self,
+        backbone,
+        num_classes,
+        preprocessor=None,
+        pooling="avg",
+        activation=None,
+        dropout=0.0,
+        head_dtype=None,
+        **kwargs,
+    ):
+        head_dtype = head_dtype or backbone.dtype_policy
+        data_format = getattr(backbone, "data_format", None)
+
+        # === Layers ===
+        self.backbone = backbone
+        self.preprocessor = preprocessor
+        if pooling == "avg":
+            self.pooler = keras.layers.GlobalAveragePooling2D(
+                data_format,
+                dtype=head_dtype,
+                name="pooler",
+            )
+        elif pooling == "max":
+            self.pooler = keras.layers.GlobalMaxPooling2D(
+                data_format,
+                dtype=head_dtype,
+                name="pooler",
+            )
+        else:
+            raise ValueError(
+                "Unknown `pooling` type. Polling should be either `'avg'` or "
+                f"`'max'`. Received: pooling={pooling}."
+            )
+        self.output_dropout = keras.layers.Dropout(
+            dropout,
+            dtype=head_dtype,
+            name="output_dropout",
+        )
+        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)
+        x = self.output_dropout(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
+        self.dropout = dropout
+
+    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,
+                "dropout": self.dropout,
+            }
+        )
+        return config
+
     def compile(
         self,
         optimizer="auto",

keras_hub/src/models/image_classifier_preprocessor.py

@@ -38,15 +38,15 @@ class ImageClassifierPreprocessor(Preprocessor):
     )
 
     # Resize a single image for resnet 50.
-    x = np.ones((512, 512, 3))
+    x = np.random.randint(0, 256, (512, 512, 3))
     x = preprocessor(x)
 
     # Resize a labeled image.
-    x, y = np.ones((512, 512, 3)), 1
+    x, y = np.random.randint(0, 256, (512, 512, 3)), 1
     x, y = preprocessor(x, y)
 
     # Resize a batch of labeled images.
-    x, y = [np.ones((512, 512, 3)), np.zeros((512, 512, 3))], [1, 0]
+    x, y = [np.random.randint(0, 256, (512, 512, 3)), np.zeros((512, 512, 3))], [1, 0]
     x, y = preprocessor(x, y)
 
     # Use a `tf.data.Dataset`.

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