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

keras_hub/src/models/deeplab_v3/deeplab_v3_image_segmeter_preprocessor.py

@@ -0,0 +1,16 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_image_converter import (
+    DeepLabV3ImageConverter,
+)
+from keras_hub.src.models.image_segmenter_preprocessor import (
+    ImageSegmenterPreprocessor,
+)
+
+
+@keras_hub_export("keras_hub.models.DeepLabV3ImageSegmenterPreprocessor")
+class DeepLabV3ImageSegmenterPreprocessor(ImageSegmenterPreprocessor):
+    backbone_cls = DeepLabV3Backbone
+    image_converter_cls = DeepLabV3ImageConverter

keras_hub/src/models/deeplab_v3/deeplab_v3_layers.py

@@ -0,0 +1,215 @@
+import keras
+from keras import ops
+
+
+class SpatialPyramidPooling(keras.layers.Layer):
+    """Implements the Atrous Spatial Pyramid Pooling.
+
+    Reference for Atrous Spatial Pyramid Pooling [Rethinking Atrous Convolution
+    for Semantic Image Segmentation](https://arxiv.org/pdf/1706.05587.pdf) and
+    [Encoder-Decoder with Atrous Separable Convolution for Semantic Image
+    Segmentation](https://arxiv.org/pdf/1802.02611.pdf)
+
+    Args:
+    dilation_rates: list of ints. The dilation rate for parallel dilated conv.
+        Usually a sample choice of rates are `[6, 12, 18]`.
+    num_channels: int. The number of output channels, defaults to `256`.
+    activation: str. Activation to be used, defaults to `relu`.
+    dropout: float. The dropout rate of the final projection output after the
+        activations and batch norm, defaults to `0.0`, which means no dropout is
+        applied to the output.
+
+    Example:
+    ```python
+    inp = keras.layers.Input((384, 384, 3))
+    backbone = keras.applications.EfficientNetB0(
+        input_tensor=inp,
+        include_top=False)
+    output = backbone(inp)
+    output = SpatialPyramidPooling(
+        dilation_rates=[6, 12, 18])(output)
+    ```
+    """
+
+    def __init__(
+        self,
+        dilation_rates,
+        num_channels=256,
+        activation="relu",
+        dropout=0.0,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.dilation_rates = dilation_rates
+        self.num_channels = num_channels
+        self.activation = activation
+        self.dropout = dropout
+        self.data_format = keras.config.image_data_format()
+        self.channel_axis = -1 if self.data_format == "channels_last" else 1
+
+    def build(self, input_shape):
+        channels = input_shape[self.channel_axis]
+
+        # This is the parallel networks that process the input features with
+        # different dilation rates. The output from each channel will be merged
+        # together and feed to the output.
+        self.aspp_parallel_channels = []
+
+        # Channel1 with Conv2D and 1x1 kernel size.
+        conv_sequential = keras.Sequential(
+            [
+                keras.layers.Conv2D(
+                    filters=self.num_channels,
+                    kernel_size=(1, 1),
+                    use_bias=False,
+                    data_format=self.data_format,
+                    name="aspp_conv_1",
+                ),
+                keras.layers.BatchNormalization(
+                    axis=self.channel_axis, name="aspp_bn_1"
+                ),
+                keras.layers.Activation(
+                    self.activation, name="aspp_activation_1"
+                ),
+            ]
+        )
+        conv_sequential.build(input_shape)
+        self.aspp_parallel_channels.append(conv_sequential)
+
+        # Channel 2 and afterwards are based on self.dilation_rates, and each of
+        # them will have conv2D with 3x3 kernel size.
+        for i, dilation_rate in enumerate(self.dilation_rates):
+            conv_sequential = keras.Sequential(
+                [
+                    keras.layers.Conv2D(
+                        filters=self.num_channels,
+                        kernel_size=(3, 3),
+                        padding="same",
+                        dilation_rate=dilation_rate,
+                        use_bias=False,
+                        data_format=self.data_format,
+                        name=f"aspp_conv_{i+2}",
+                    ),
+                    keras.layers.BatchNormalization(
+                        axis=self.channel_axis, name=f"aspp_bn_{i+2}"
+                    ),
+                    keras.layers.Activation(
+                        self.activation, name=f"aspp_activation_{i+2}"
+                    ),
+                ]
+            )
+            conv_sequential.build(input_shape)
+            self.aspp_parallel_channels.append(conv_sequential)
+
+        # Last channel is the global average pooling with conv2D 1x1 kernel.
+        if self.channel_axis == -1:
+            reshape = keras.layers.Reshape((1, 1, channels), name="reshape")
+        else:
+            reshape = keras.layers.Reshape((channels, 1, 1), name="reshape")
+        pool_sequential = keras.Sequential(
+            [
+                keras.layers.GlobalAveragePooling2D(
+                    data_format=self.data_format, name="average_pooling"
+                ),
+                reshape,
+                keras.layers.Conv2D(
+                    filters=self.num_channels,
+                    kernel_size=(1, 1),
+                    use_bias=False,
+                    data_format=self.data_format,
+                    name="conv_pooling",
+                ),
+                keras.layers.BatchNormalization(
+                    axis=self.channel_axis, name="bn_pooling"
+                ),
+                keras.layers.Activation(
+                    self.activation, name="activation_pooling"
+                ),
+            ]
+        )
+        pool_sequential.build(input_shape)
+        self.aspp_parallel_channels.append(pool_sequential)
+
+        # Final projection layers
+        projection = keras.Sequential(
+            [
+                keras.layers.Conv2D(
+                    filters=self.num_channels,
+                    kernel_size=(1, 1),
+                    use_bias=False,
+                    data_format=self.data_format,
+                    name="conv_projection",
+                ),
+                keras.layers.BatchNormalization(
+                    axis=self.channel_axis, name="bn_projection"
+                ),
+                keras.layers.Activation(
+                    self.activation, name="activation_projection"
+                ),
+                keras.layers.Dropout(rate=self.dropout, name="dropout"),
+            ],
+        )
+        projection_input_channels = (
+            2 + len(self.dilation_rates)
+        ) * self.num_channels
+        if self.data_format == "channels_first":
+            projection.build(
+                (input_shape[0],)
+                + (projection_input_channels,)
+                + (input_shape[2:])
+            )
+        else:
+            projection.build((input_shape[:-1]) + (projection_input_channels,))
+        self.projection = projection
+        self.built = True
+
+    def call(self, inputs):
+        """Calls the Atrous Spatial Pyramid Pooling layer on an input.
+
+        Args:
+            inputs: A tensor of shape [batch, height, width, channels]
+
+        Returns:
+            A tensor of shape [batch, height, width, num_channels]
+        """
+        result = []
+
+        for channel in self.aspp_parallel_channels:
+            temp = ops.cast(channel(inputs), inputs.dtype)
+            result.append(temp)
+
+        image_shape = ops.shape(inputs)
+        if self.channel_axis == -1:
+            height, width = image_shape[1], image_shape[2]
+        else:
+            height, width = image_shape[2], image_shape[3]
+        result[-1] = keras.layers.Resizing(
+            height,
+            width,
+            interpolation="bilinear",
+            data_format=self.data_format,
+            name="resizing",
+        )(result[-1])
+
+        result = ops.concatenate(result, axis=self.channel_axis)
+        return self.projection(result)
+
+    def compute_output_shape(self, inputs_shape):
+        if self.data_format == "channels_first":
+            return tuple(
+                (inputs_shape[0],) + (self.num_channels,) + (inputs_shape[2:])
+            )
+        else:
+            return tuple((inputs_shape[:-1]) + (self.num_channels,))
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "dilation_rates": self.dilation_rates,
+                "num_channels": self.num_channels,
+                "activation": self.activation,
+                "dropout": self.dropout,
+            }
+        )
+        return config

keras_hub/src/models/deeplab_v3/deeplab_v3_presets.py

@@ -0,0 +1,4 @@
+"""DeepLabV3 preset configurations."""
+
+# TODO https://github.com/keras-team/keras-hub/issues/1896,
+backbone_presets = {}

keras_hub/src/models/deeplab_v3/deeplab_v3_segmenter.py

@@ -0,0 +1,109 @@
+import keras
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.deeplab_v3.deeplab_v3_backbone import (
+    DeepLabV3Backbone,
+)
+from keras_hub.src.models.deeplab_v3.deeplab_v3_image_segmeter_preprocessor import (
+    DeepLabV3ImageSegmenterPreprocessor,
+)
+from keras_hub.src.models.image_segmenter import ImageSegmenter
+
+
+@keras_hub_export("keras_hub.models.DeepLabV3ImageSegmenter")
+class DeepLabV3ImageSegmenter(ImageSegmenter):
+    """DeepLabV3 and DeeplabV3 and DeeplabV3Plus segmentation task.
+
+    Args:
+        backbone: A `keras_hub.models.DeepLabV3` instance.
+        num_classes: int. The number of classes for the detection model. Note
+            that the `num_classes` contains the background class, and the
+            classes from the data should be represented by integers with range
+            `[0, num_classes]`.
+        activation: str or callable. The activation function to use on
+            the `Dense` layer. Set `activation=None` to return the output
+            logits. Defaults to `None`.
+        preprocessor: A `keras_hub.models.DeepLabV3ImageSegmenterPreprocessor`
+            or `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
+
+    Example:
+    Load a DeepLabV3 preset with all the 21 class, pretrained segmentation head.
+    ```python
+    images = np.ones(shape=(1, 96, 96, 3))
+    labels = np.zeros(shape=(1, 96, 96, 1))
+    segmenter = keras_hub.models.DeepLabV3ImageSegmenter.from_preset(
+        "deeplabv3_resnet50_pascalvoc",
+    )
+    segmenter.predict(images)
+    ```
+
+    Specify `num_classes` to load randomly initialized segmentation head.
+    ```python
+    segmenter = keras_hub.models.DeepLabV3ImageSegmenter.from_preset(
+        "deeplabv3_resnet50_pascalvoc",
+        num_classes=2,
+    )
+    segmenter.fit(images, labels, epochs=3)
+    segmenter.predict(images)  # Trained 2 class segmentation.
+    ```
+    Load DeepLabv3+ presets a extension of DeepLabv3 by adding a simple yet
+    effective decoder module to refine the segmentation results especially
+    along object boundaries.
+    ```python
+    segmenter = keras_hub.models.DeepLabV3ImageSegmenter.from_preset(
+        "deeplabv3_plus_resnet50_pascalvoc",
+    )
+    segmenter.predict(images)
+    ```
+    """
+
+    backbone_cls = DeepLabV3Backbone
+    preprocessor_cls = DeepLabV3ImageSegmenterPreprocessor
+
+    def __init__(
+        self,
+        backbone,
+        num_classes,
+        activation=None,
+        preprocessor=None,
+        **kwargs,
+    ):
+        data_format = keras.config.image_data_format()
+        # === Layers ===
+        self.output_conv = keras.layers.Conv2D(
+            name="segmentation_output",
+            filters=num_classes,
+            kernel_size=1,
+            use_bias=False,
+            padding="same",
+            activation=activation,
+            data_format=data_format,
+        )
+
+        # === Functional Model ===
+        inputs = backbone.input
+        x = backbone(inputs)
+        outputs = self.output_conv(x)
+        super().__init__(
+            inputs=inputs,
+            outputs=outputs,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.backbone = backbone
+        self.num_classes = num_classes
+        self.activation = activation
+        self.preprocessor = preprocessor
+
+    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/densenet/densenet_image_classifier.py

@@ -1,5 +1,3 @@
-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 (
@@ -10,131 +8,5 @@ from keras_hub.src.models.image_classifier import ImageClassifier
 
 @keras_hub_export("keras_hub.models.DenseNetImageClassifier")
 class DenseNetImageClassifier(ImageClassifier):
-    """DenseNet 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.DenseNetBackbone` 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 `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:
-
-    Call `predict()` to run inference.
-    ```python
-    # Load preset and train
-    images = np.ones((2, 224, 224, 3), dtype="float32")
-    classifier = keras_hub.models.DenseNetImageClassifier.from_preset(
-        "densenet121_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.DenseNetImageClassifier.from_preset(
-        "densenet121_imagenet")
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-
-    Call `fit()` with custom loss, optimizer and backbone.
-    ```python
-    classifier = keras_hub.models.DenseNetImageClassifier.from_preset(
-        "densenet121_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.DenseNetBackbone(
-        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.DenseNetImageClassifier(
-        backbone=backbone,
-        num_classes=4,
-    )
-    classifier.fit(x=images, y=labels, batch_size=2)
-    ```
-    """
-
     backbone_cls = DenseNetBackbone
     preprocessor_cls = DenseNetImageClassifierPreprocessor
-
-    def __init__(
-        self,
-        backbone,
-        num_classes,
-        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,
-            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,
-                "activation": self.activation,
-                "pooling": self.pooling,
-            }
-        )
-        return config

keras_hub/src/models/densenet/densenet_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.densenet.densenet_backbone import DenseNetBackbone
 
 
 @keras_hub_export("keras_hub.layers.DenseNetImageConverter")
-class DenseNetImageConverter(ResizingImageConverter):
+class DenseNetImageConverter(ImageConverter):
     backbone_cls = DenseNetBackbone

keras_hub/src/models/feature_pyramid_backbone.py

@@ -15,7 +15,7 @@ class FeaturePyramidBackbone(Backbone):
     Example:
 
     ```python
-    input_data = np.random.uniform(0, 255, size=(2, 224, 224, 3))
+    input_data = np.random.uniform(0, 256, size=(2, 224, 224, 3))
 
     # Convert to feature pyramid output format using ResNet.
     backbone = ResNetBackbone.from_preset("resnet50")

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`.