keras-hub-nightly 0.16.1.dev202409240339__py3-none-any.whl → 0.16.1.dev202409260340__py3-none-any.whl

keras_hub/src/models/densenet/densenet_backbone.py

@@ -92,11 +92,14 @@ class DenseNetBackbone(FeaturePyramidBackbone):
                 channel_axis,
                 stackwise_num_repeats[stack_index],
                 growth_rate,
-                name=f"conv{index}",
+                name=f"stack{stack_index+1}",
             )
             pyramid_outputs[f"P{index}"] = x
             x = apply_transition_block(
-                x, channel_axis, compression_ratio, name=f"pool{index}"
+                x,
+                channel_axis,
+                compression_ratio,
+                name=f"transition{stack_index+1}",
             )
 
         x = apply_dense_block(
@@ -104,7 +107,7 @@ class DenseNetBackbone(FeaturePyramidBackbone):
             channel_axis,
             stackwise_num_repeats[-1],
             growth_rate,
-            name=f"conv{len(stackwise_num_repeats) + 1}",
+            name=f"stack{len(stackwise_num_repeats)}",
         )
         pyramid_outputs[f"P{len(stackwise_num_repeats) + 1}"] = x
         x = keras.layers.BatchNormalization(
@@ -148,7 +151,7 @@ def apply_dense_block(x, channel_axis, num_repeats, growth_rate, name=None):
 
     for i in range(num_repeats):
         x = apply_conv_block(
-            x, channel_axis, growth_rate, name=f"{name}_block_{i}"
+            x, channel_axis, growth_rate, name=f"{name}_block{i+1}"
         )
     return x
 
@@ -196,9 +199,9 @@ def apply_conv_block(x, channel_axis, growth_rate, name=None):
 
     shortcut = x
     x = keras.layers.BatchNormalization(
-        axis=channel_axis, epsilon=BN_EPSILON, name=f"{name}_0_bn"
+        axis=channel_axis, epsilon=BN_EPSILON, name=f"{name}_1_bn"
     )(x)
-    x = keras.layers.Activation("relu", name=f"{name}_0_relu")(x)
+    x = keras.layers.Activation("relu", name=f"{name}_1_relu")(x)
     x = keras.layers.Conv2D(
         4 * growth_rate,
         1,
@@ -207,9 +210,9 @@ def apply_conv_block(x, channel_axis, growth_rate, name=None):
         name=f"{name}_1_conv",
     )(x)
     x = keras.layers.BatchNormalization(
-        axis=channel_axis, epsilon=BN_EPSILON, name=f"{name}_1_bn"
+        axis=channel_axis, epsilon=BN_EPSILON, name=f"{name}_2_bn"
     )(x)
-    x = keras.layers.Activation("relu", name=f"{name}_1_relu")(x)
+    x = keras.layers.Activation("relu", name=f"{name}_2_relu")(x)
     x = keras.layers.Conv2D(
         growth_rate,
         3,

keras_hub/src/models/densenet/densenet_image_classifier.py

@@ -15,6 +15,9 @@ import keras
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.densenet.densenet_backbone import DenseNetBackbone
+from keras_hub.src.models.densenet.densenet_image_classifier_preprocessor import (
+    DenseNetImageClassifierPreprocessor,
+)
 from keras_hub.src.models.image_classifier import ImageClassifier
 
 
@@ -32,7 +35,13 @@ class DenseNetImageClassifier(ImageClassifier):
         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"`.
+            logits. Defaults to `None`.
+        pooling: A pooling layer to use before the final classification layer,
+            must be one of "avg" or "max". Use "avg" for
+            `GlobalAveragePooling2D` and "max" for "GlobalMaxPooling2D.
+        preprocessor: A `keras_hub.models.DenseNetImageClassifierPreprocessor`
+            or `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
 
     Examples:
 
@@ -86,18 +95,29 @@ class DenseNetImageClassifier(ImageClassifier):
     """
 
     backbone_cls = DenseNetBackbone
+    preprocessor_cls = DenseNetImageClassifierPreprocessor
 
     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
+        activation=None,
+        pooling="avg",
+        preprocessor=None,
         **kwargs,
     ):
         # === Layers ===
         self.backbone = backbone
+        self.preprocessor = preprocessor
+        if pooling == "avg":
+            self.pooler = keras.layers.GlobalAveragePooling2D()
+        elif pooling == "max":
+            self.pooler = keras.layers.GlobalMaxPooling2D()
+        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,
@@ -107,6 +127,7 @@ class DenseNetImageClassifier(ImageClassifier):
         # === Functional Model ===
         inputs = self.backbone.input
         x = self.backbone(inputs)
+        x = self.pooler(x)
         outputs = self.output_dense(x)
         super().__init__(
             inputs=inputs,
@@ -117,6 +138,7 @@ class DenseNetImageClassifier(ImageClassifier):
         # === Config ===
         self.num_classes = num_classes
         self.activation = activation
+        self.pooling = pooling
 
     def get_config(self):
         # Backbone serialized in `super`
@@ -125,6 +147,7 @@ class DenseNetImageClassifier(ImageClassifier):
             {
                 "num_classes": self.num_classes,
                 "activation": self.activation,
+                "pooling": self.pooling,
             }
         )
         return config

keras_hub/src/models/densenet/densenet_image_classifier_preprocessor.py

@@ -0,0 +1,27 @@
+# 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.models.densenet.densenet_backbone import DenseNetBackbone
+from keras_hub.src.models.densenet.densenet_image_converter import (
+    DenseNetImageConverter,
+)
+from keras_hub.src.models.image_classifier_preprocessor import (
+    ImageClassifierPreprocessor,
+)
+
+
+@keras_hub_export("keras_hub.models.DenseNetImageClassifierPreprocessor")
+class DenseNetImageClassifierPreprocessor(ImageClassifierPreprocessor):
+    backbone_cls = DenseNetBackbone
+    image_converter_cls = DenseNetImageConverter

keras_hub/src/models/densenet/densenet_image_converter.py

@@ -0,0 +1,23 @@
+# 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.resizing_image_converter import (
+    ResizingImageConverter,
+)
+from keras_hub.src.models.densenet.densenet_backbone import DenseNetBackbone
+
+
+@keras_hub_export("keras_hub.layers.DenseNetImageConverter")
+class DenseNetImageConverter(ResizingImageConverter):
+    backbone_cls = DenseNetBackbone

keras_hub/src/models/densenet/densenet_presets.py

@@ -0,0 +1,56 @@
+# 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.
+"""DenseNet preset configurations."""
+
+backbone_presets = {
+    "densenet_121_imagenet": {
+        "metadata": {
+            "description": (
+                "121-layer DenseNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 7037504,
+            "official_name": "DenseNet",
+            "path": "densenet",
+            "model_card": "https://arxiv.org/abs/1608.06993",
+        },
+        "kaggle_handle": "kaggle://kerashub/densenet/keras/densenet_121_imagenet",
+    },
+    "densenet_169_imagenet": {
+        "metadata": {
+            "description": (
+                "169-layer DenseNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 12642880,
+            "official_name": "DenseNet",
+            "path": "densenet",
+            "model_card": "https://arxiv.org/abs/1608.06993",
+        },
+        "kaggle_handle": "kaggle://kerashub/densenet/keras/densenet_169_imagenet",
+    },
+    "densenet_201_imagenet": {
+        "metadata": {
+            "description": (
+                "201-layer DenseNet model pre-trained on the ImageNet 1k dataset "
+                "at a 224x224 resolution."
+            ),
+            "params": 18321984,
+            "official_name": "DenseNet",
+            "path": "densenet",
+            "model_card": "https://arxiv.org/abs/1608.06993",
+        },
+        "kaggle_handle": "kaggle://kerashub/densenet/keras/densenet_201_imagenet",
+    },
+}

keras_hub/src/models/image_segmenter.py

@@ -0,0 +1,86 @@
+# 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.
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.task import Task
+
+
+@keras_hub_export("keras_hub.models.ImageSegmenter")
+class ImageSegmenter(Task):
+    """Base class for all image segmentation tasks.
+
+    `ImageSegmenter` tasks wrap a `keras_hub.models.Task` and
+    a `keras_hub.models.Preprocessor` to create a model that can be used for
+    image segmentation.
+
+    All `ImageSegmenter` tasks include a `from_preset()` constructor which can
+    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",
+        loss="auto",
+        *,
+        metrics="auto",
+        **kwargs,
+    ):
+        """Configures the `ImageSegmenter` task for training.
+
+        The `ImageSegmenter` task extends the default compilation signature of
+        `keras.Model.compile` with defaults for `optimizer`, `loss`, and
+        `metrics`. To override these defaults, pass any value
+        to these arguments during compilation.
+
+        Args:
+            optimizer: `"auto"`, an optimizer name, or a `keras.Optimizer`
+                instance. Defaults to `"auto"`, which uses the default optimizer
+                for the given model and task. See `keras.Model.compile` and
+                `keras.optimizers` for more info on possible `optimizer` values.
+            loss: `"auto"`, a loss name, or a `keras.losses.Loss` instance.
+                Defaults to `"auto"`, where a
+                `keras.losses.SparseCategoricalCrossentropy` loss will be
+                applied for the classification task. See
+                `keras.Model.compile` and `keras.losses` for more info on
+                possible `loss` values.
+            metrics: `"auto"`, or a list of metrics to be evaluated by
+                the model during training and testing. Defaults to `"auto"`,
+                where a `keras.metrics.SparseCategoricalAccuracy` will be
+                applied to track the accuracy of the model during training.
+                See `keras.Model.compile` and `keras.metrics` for
+                more info on possible `metrics` values.
+            **kwargs: See `keras.Model.compile` for a full list of arguments
+                supported by the compile method.
+        """
+        if optimizer == "auto":
+            optimizer = keras.optimizers.Adam(5e-5)
+        if loss == "auto":
+            activation = getattr(self, "activation", None)
+            activation = keras.activations.get(activation)
+            from_logits = activation != keras.activations.softmax
+            loss = keras.losses.CategoricalCrossentropy(from_logits=from_logits)
+        if metrics == "auto":
+            metrics = [keras.metrics.CategoricalAccuracy()]
+        super().compile(
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics,
+            **kwargs,
+        )

keras_hub/src/models/sam/__init__.py

@@ -0,0 +1,13 @@
+# 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.

keras_hub/src/models/sam/sam_backbone.py

@@ -0,0 +1,153 @@
+# 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.
+
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+
+
+@keras_hub_export("keras_hub.models.SAMBackbone")
+class SAMBackbone(Backbone):
+    """A backbone for the Segment Anything Model (SAM).
+
+    Args:
+        image_encoder: `keras_hub.models.ViTDetBackbone`. A feature extractor for
+            the input images.
+        prompt_encoder: `keras_hub.layers.SAMPromptEncoder`. A Keras layer to
+            compute embeddings for points, box, and mask prompt.
+        mask_decoder: `keras_hub.layers.SAMMaskDecoder`. A Keras layer to
+            generate segmentation masks given the embeddings generated by the
+            backbone and the prompt encoder.
+        dtype: The dtype of the layer weights.
+
+    Example:
+    ```python
+    image_size=128
+    batch_size=2
+    input_data = {
+        "images": np.ones(
+            (batch_size, image_size, image_size, 3),
+            dtype="float32",
+        ),
+        "points": np.ones((batch_size, 1, 2), dtype="float32"),
+        "labels": np.ones((batch_size, 1), dtype="float32"),
+        "boxes": np.ones((batch_size, 1, 2, 2), dtype="float32"),
+        "masks": np.zeros(
+            (batch_size, 0, image_size, image_size, 1)
+        ),
+    }
+    image_encoder = keras_hub.models.ViTDetBackbone(
+        hidden_size=16,
+        num_layers=16,
+        intermediate_dim=16 * 4,
+        num_heads=16,
+        global_attention_layer_indices=[2, 5, 8, 11],
+        patch_size=16,
+        num_output_channels=8,
+        window_size=2,
+        image_shape=(image_size, image_size, 3),
+    )
+    prompt_encoder = keras_hub.layers.SAMPromptEncoder(
+        hidden_size=8,
+        image_embedding_size=(8, 8),
+        input_image_size=(
+            image_size,
+            image_size,
+        ),
+        mask_in_channels=16,
+    )
+    mask_decoder = keras_hub.layers.SAMMaskDecoder(
+        num_layers=2,
+        hidden_size=8,
+        intermediate_dim=32,
+        num_heads=8,
+        embedding_dim=8,
+        num_multimask_outputs=3,
+        iou_head_depth=3,
+        iou_head_hidden_dim=8,
+    )
+    backbone = keras_hub.models.SAMBackbone(
+        image_encoder=image_encoder,
+        prompt_encoder=prompt_encoder,
+        mask_decoder=mask_decoder,
+        image_shape=(image_size, image_size, 3),
+    )
+    backbone(input_data)
+    ```
+    """
+
+    def __init__(
+        self,
+        image_encoder,
+        prompt_encoder,
+        mask_decoder,
+        dtype=None,
+        **kwargs,
+    ):
+        # === Layers ===
+        self.image_encoder = image_encoder
+        self.prompt_encoder = prompt_encoder
+        self.mask_decoder = mask_decoder
+        # === Functional model
+        image_input = self.image_encoder.input
+
+        inputs = {
+            "images": image_input,
+            "points": keras.Input(shape=[None, 2], name="points"),
+            "labels": keras.Input(shape=[None], name="labels"),
+            "boxes": keras.Input(shape=[None, 2, 2], name="boxes"),
+            "masks": keras.Input(shape=[None, None, None, 1], name="masks"),
+        }
+        image_embeddings = self.image_encoder.output
+        prompt_embeddings = self.prompt_encoder(**inputs)
+        outputs = {
+            "image_embeddings": image_embeddings,
+        }
+        outputs.update(prompt_embeddings)
+        super().__init__(
+            inputs=inputs,
+            outputs=outputs,
+            dtype=dtype,
+            **kwargs,
+        )
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_encoder": keras.layers.serialize(self.image_encoder),
+                "prompt_encoder": keras.layers.serialize(self.prompt_encoder),
+                "mask_decoder": keras.layers.serialize(self.mask_decoder),
+            }
+        )
+        return config
+
+    @classmethod
+    def from_config(cls, config):
+        config.update(
+            {
+                "image_encoder": keras.layers.deserialize(
+                    config["image_encoder"]
+                ),
+                "prompt_encoder": keras.layers.deserialize(
+                    config["prompt_encoder"]
+                ),
+                "mask_decoder": keras.layers.deserialize(
+                    config["mask_decoder"]
+                ),
+            }
+        )
+
+        return super().from_config(config)