keras-hub-nightly 0.16.1.dev202410010346__tar.gz → 0.16.1.dev202410030339__tar.gz

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: keras-hub-nightly
-Version: 0.16.1.dev202410010346
+Version: 0.16.1.dev202410030339
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/keras_hub/api/layers/__init__.py

@@ -33,9 +33,6 @@ from keras_hub.src.layers.preprocessing.multi_segment_packer import (
 )
 from keras_hub.src.layers.preprocessing.random_deletion import RandomDeletion
 from keras_hub.src.layers.preprocessing.random_swap import RandomSwap
-from keras_hub.src.layers.preprocessing.resizing_image_converter import (
-    ResizingImageConverter,
-)
 from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
 from keras_hub.src.models.densenet.densenet_image_converter import (
     DenseNetImageConverter,

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/keras_hub/api/models/__init__.py

@@ -254,7 +254,7 @@ from keras_hub.src.models.roberta.roberta_tokenizer import RobertaTokenizer
 from keras_hub.src.models.sam.sam_backbone import SAMBackbone
 from keras_hub.src.models.sam.sam_image_segmenter import SAMImageSegmenter
 from keras_hub.src.models.sam.sam_image_segmenter_preprocessor import (
-    SAMImageSegmenterPreprocessor as SamImageSegmenterPreprocessor,
+    SAMImageSegmenterPreprocessor,
 )
 from keras_hub.src.models.seq_2_seq_lm import Seq2SeqLM
 from keras_hub.src.models.seq_2_seq_lm_preprocessor import Seq2SeqLMPreprocessor

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/keras_hub/src/layers/preprocessing/audio_converter.py

@@ -2,11 +2,10 @@ from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.preprocessing_layer import (
     PreprocessingLayer,
 )
-from keras_hub.src.utils.preset_utils import AUDIO_CONVERTER_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
 
 
@@ -101,8 +100,5 @@ class AudioConverter(PreprocessingLayer):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(
-            self,
-            preset_dir,
-            config_file=AUDIO_CONVERTER_CONFIG_FILE,
-        )
+        saver = get_preset_saver(preset_dir)
+        saver.save_audio_converter(self)

keras_hub_nightly-0.16.1.dev202410030339/keras_hub/src/layers/preprocessing/image_converter.py

@@ -0,0 +1,247 @@
+import math
+
+import keras
+import numpy as np
+from keras import ops
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.layers.preprocessing.preprocessing_layer import (
+    PreprocessingLayer,
+)
+from keras_hub.src.utils.keras_utils import standardize_data_format
+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 get_preset_saver
+from keras_hub.src.utils.python_utils import classproperty
+from keras_hub.src.utils.tensor_utils import preprocessing_function
+
+
+@keras_hub_export("keras_hub.layers.ImageConverter")
+class ImageConverter(PreprocessingLayer):
+    """Preprocess raw images into model ready inputs.
+
+    This class converts from raw images to model ready inputs. This conversion
+    proceeds in the following steps:
+
+    1. Resize the image using to `image_size`. If `image_size` is `None`, this
+       step will be skipped.
+    2. Rescale the image by multiplying by `scale`, which can be either global
+       or per channel. If `scale` is `None`, this step will be skipped.
+    3. Offset the image by adding `offset`, which can be either global
+       or per channel. If `offset` is `None`, this step will be skipped.
+
+    The layer will take as input a raw image tensor in the channels last or
+    channels first format, and output a preprocessed image input for modeling.
+    This tensor can be batched (rank 4), or unbatched (rank 3).
+
+    This layer can be used with the `from_preset()` constructor to load a layer
+    that will rescale and resize an image for a specific pretrained model.
+    Using the layer this way allows writing preprocessing code that does not
+    need updating when switching between model checkpoints.
+
+    Args:
+        image_size: `(int, int)` tuple or `None`. The output size of the image,
+            not including the channels axis. If `None`, the input will not be
+            resized.
+        scale: float, tuple of floats, or `None`. The scale to apply to the
+            inputs. If `scale` is a single float, the entire input will be
+            multiplied by `scale`. If `scale` is a tuple, it's assumed to
+            contain per-channel scale value multiplied against each channel of
+            the input images. If `scale` is `None`, no scaling is applied.
+        offset: float, tuple of floats, or `None`. The offset to apply to the
+            inputs. If `offset` is a single float, the entire input will be
+            summed with `offset`. If `offset` is a tuple, it's assumed to
+            contain per-channel offset value summed against each channel of the
+            input images. If `offset` is `None`, no scaling is applied.
+        crop_to_aspect_ratio: If `True`, resize the images without aspect
+            ratio distortion. When the original aspect ratio differs
+            from the target aspect ratio, the output image will be
+            cropped so as to return the
+            largest possible window in the image (of size `(height, width)`)
+            that matches the target aspect ratio. By default
+            (`crop_to_aspect_ratio=False`), aspect ratio may not be preserved.
+        interpolation: String, the interpolation method.
+            Supports `"bilinear"`, `"nearest"`, `"bicubic"`,
+            `"lanczos3"`, `"lanczos5"`. Defaults to `"bilinear"`.
+        data_format: String, either `"channels_last"` or `"channels_first"`.
+            The ordering of the dimensions in the inputs. `"channels_last"`
+            corresponds to inputs with shape `(batch, height, width, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch, channels, height, width)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
+
+    Examples:
+    ```python
+    # Resize raw images and scale them to [0, 1].
+    converter = keras_hub.layers.ImageConverter(
+        image_size=(128, 128),
+        scale=1. / 255,
+    )
+    converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))
+
+    # Resize images to the specific size needed for a PaliGemma preset.
+    converter = keras_hub.layers.ImageConverter.from_preset(
+        "pali_gemma_3b_224"
+    )
+    converter(np.random.randint(0, 256, size=(2, 512, 512, 3)))
+    ```
+    """
+
+    backbone_cls = None
+
+    def __init__(
+        self,
+        image_size=None,
+        scale=None,
+        offset=None,
+        crop_to_aspect_ratio=True,
+        interpolation="bilinear",
+        data_format=None,
+        **kwargs,
+    ):
+        # TODO: old arg names. Delete this block after resaving Kaggle assets.
+        if "height" in kwargs and "width" in kwargs:
+            image_size = (kwargs.pop("height"), kwargs.pop("width"))
+        if "variance" in kwargs and "mean" in kwargs:
+            std = [math.sqrt(v) for v in kwargs.pop("variance")]
+            scale = [scale / s for s in std]
+            offset = [-m / s for m, s in zip(kwargs.pop("mean"), std)]
+
+        super().__init__(**kwargs)
+
+        # Create the `Resizing` layer here even if it's not being used. That
+        # allows us to make `image_size` a settable property.
+        self.resizing = keras.layers.Resizing(
+            height=image_size[0] if image_size else None,
+            width=image_size[1] if image_size else None,
+            crop_to_aspect_ratio=crop_to_aspect_ratio,
+            interpolation=interpolation,
+            data_format=data_format,
+            dtype=self.dtype_policy,
+            name="resizing",
+        )
+        self.scale = scale
+        self.offset = offset
+        self.crop_to_aspect_ratio = crop_to_aspect_ratio
+        self.interpolation = interpolation
+        self.data_format = standardize_data_format(data_format)
+
+    @property
+    def image_size(self):
+        """Settable tuple of `(height, width)` ints. The output image shape."""
+        if self.resizing.height is None:
+            return None
+        return (self.resizing.height, self.resizing.width)
+
+    @image_size.setter
+    def image_size(self, value):
+        if value is None:
+            value = (None, None)
+        self.resizing.height = value[0]
+        self.resizing.width = value[1]
+
+    @preprocessing_function
+    def call(self, inputs):
+        if self.image_size is not None:
+            x = self.resizing(inputs)
+        if self.scale is not None:
+            x = x * self._expand_non_channel_dims(self.scale, x)
+        if self.offset is not None:
+            x = x + self._expand_non_channel_dims(self.offset, x)
+        return x
+
+    def _expand_non_channel_dims(self, value, inputs):
+        unbatched = len(ops.shape(inputs)) == 3
+        channels_first = self.data_format == "channels_first"
+        if unbatched:
+            broadcast_dims = (1, 2) if channels_first else (0, 1)
+        else:
+            broadcast_dims = (0, 2, 3) if channels_first else (0, 1, 2)
+        # If inputs are not a tensor type, return a numpy array.
+        # This might happen when running under tf.data.
+        if ops.is_tensor(inputs):
+            return ops.expand_dims(value, broadcast_dims)
+        else:
+            return np.expand_dims(value, broadcast_dims)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "image_size": self.image_size,
+                "scale": self.scale,
+                "offset": self.offset,
+                "interpolation": self.interpolation,
+                "crop_to_aspect_ratio": self.crop_to_aspect_ratio,
+            }
+        )
+        return config
+
+    @classproperty
+    def presets(cls):
+        """List built-in presets for an `ImageConverter` subclass."""
+        return builtin_presets(cls)
+
+    @classmethod
+    def from_preset(
+        cls,
+        preset,
+        **kwargs,
+    ):
+        """Instantiate a `keras_hub.layers.ImageConverter` from a model preset.
+
+        A preset is a directory of configs, weights and other file assets used
+        to save and load a pre-trained model. The `preset` can be passed as
+        one of:
+
+        1. a built-in preset identifier like `'pali_gemma_3b_224'`
+        2. a Kaggle Models handle like
+           `'kaggle://user/paligemma/keras/pali_gemma_3b_224'`
+        3. a Hugging Face handle like `'hf://user/pali_gemma_3b_224'`
+        4. a path to a local preset directory like `'./pali_gemma_3b_224'`
+
+        You can run `cls.presets.keys()` to list all built-in presets available
+        on the class.
+
+        Args:
+            preset: string. A built-in preset identifier, a Kaggle Models
+                handle, a Hugging Face handle, or a path to a local directory.
+            load_weights: bool. If `True`, the weights will be loaded into the
+                model architecture. If `False`, the weights will be randomly
+                initialized.
+
+        Examples:
+        ```python
+        batch = np.random.randint(0, 256, size=(2, 512, 512, 3))
+
+        # Resize images for `"pali_gemma_3b_224"`.
+        converter = keras_hub.layers.ImageConverter.from_preset(
+            "pali_gemma_3b_224"
+        )
+        converter(batch) # Output shape: (2, 224, 224, 3)
+
+        # Resize images for `"pali_gemma_3b_448"` without cropping.
+        converter = keras_hub.layers.ImageConverter.from_preset(
+            "pali_gemma_3b_448",
+            crop_to_aspect_ratio=False,
+        )
+        converter(batch) # Output shape: (2, 448, 448, 3)
+        ```
+        """
+        loader = get_preset_loader(preset)
+        backbone_cls = loader.check_backbone_class()
+        if cls.backbone_cls != backbone_cls:
+            cls = find_subclass(preset, cls, backbone_cls)
+        return loader.load_image_converter(cls, **kwargs)
+
+    def save_to_preset(self, preset_dir):
+        """Save image converter to a preset directory.
+
+        Args:
+            preset_dir: The path to the local model preset directory.
+        """
+        saver = get_preset_saver(preset_dir)
+        saver.save_image_converter(self)

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/keras_hub/src/models/backbone.py

@@ -1,15 +1,10 @@
-import os
-
 import keras
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.utils.keras_utils import assert_quantization_support
-from keras_hub.src.utils.preset_utils import CONFIG_FILE
-from keras_hub.src.utils.preset_utils import MODEL_WEIGHTS_FILE
 from keras_hub.src.utils.preset_utils import builtin_presets
 from keras_hub.src.utils.preset_utils import get_preset_loader
-from keras_hub.src.utils.preset_utils import save_metadata
-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
 
 
@@ -193,9 +188,8 @@ class Backbone(keras.Model):
         Args:
             preset_dir: The path to the local model preset directory.
         """
-        save_serialized_object(self, preset_dir, config_file=CONFIG_FILE)
-        self.save_weights(os.path.join(preset_dir, MODEL_WEIGHTS_FILE))
-        save_metadata(self, preset_dir)
+        saver = get_preset_saver(preset_dir)
+        saver.save_backbone(self)
 
     def enable_lora(self, rank):
         """Enable Lora on the backbone.

keras_hub_nightly-0.16.1.dev202410030339/keras_hub/src/models/csp_darknet/csp_darknet_image_classifier.py

@@ -0,0 +1,10 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.csp_darknet.csp_darknet_backbone import (
+    CSPDarkNetBackbone,
+)
+from keras_hub.src.models.image_classifier import ImageClassifier
+
+
+@keras_hub_export("keras_hub.models.CSPDarkNetImageClassifier")
+class CSPDarkNetImageClassifier(ImageClassifier):
+    backbone_cls = CSPDarkNetBackbone

keras_hub_nightly-0.16.1.dev202410030339/keras_hub/src/models/densenet/densenet_image_classifier.py

@@ -0,0 +1,12 @@
+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
+
+
+@keras_hub_export("keras_hub.models.DenseNetImageClassifier")
+class DenseNetImageClassifier(ImageClassifier):
+    backbone_cls = DenseNetBackbone
+    preprocessor_cls = DenseNetImageClassifierPreprocessor

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/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_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/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_nightly-0.16.1.dev202410030339/keras_hub/src/models/image_classifier.py

@@ -0,0 +1,217 @@
+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.ImageClassifier")
+class ImageClassifier(Task):
+    """Base class for all image classification tasks.
+
+    `ImageClassifier` tasks wrap a `keras_hub.models.Backbone` and
+    a `keras_hub.models.Preprocessor` to create a model that can be used for
+    image classification. `ImageClassifier` tasks take an additional
+    `num_classes` argument, controlling the number of predicted output classes.
+
+    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.
+
+    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",
+        loss="auto",
+        *,
+        metrics="auto",
+        **kwargs,
+    ):
+        """Configures the `ImageClassifier` task for training.
+
+        The `ImageClassifier` 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.SparseCategoricalCrossentropy(from_logits)
+        if metrics == "auto":
+            metrics = [keras.metrics.SparseCategoricalAccuracy()]
+        super().compile(
+            optimizer=optimizer,
+            loss=loss,
+            metrics=metrics,
+            **kwargs,
+        )

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/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_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/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_nightly-0.16.1.dev202410030339/keras_hub/src/models/mix_transformer/mix_transformer_classifier.py

@@ -0,0 +1,10 @@
+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 (
+    MiTBackbone,
+)
+
+
+@keras_hub_export("keras_hub.models.MiTImageClassifier")
+class MiTImageClassifier(ImageClassifier):
+    backbone_cls = MiTBackbone

keras_hub_nightly-0.16.1.dev202410030339/keras_hub/src/models/mobilenet/mobilenet_image_classifier.py

@@ -0,0 +1,8 @@
+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
+
+
+@keras_hub_export("keras_hub.models.MobileNetImageClassifier")
+class MobileNetImageClassifier(ImageClassifier):
+    backbone_cls = MobileNetBackbone

{keras_hub_nightly-0.16.1.dev202410010346 → keras_hub_nightly-0.16.1.dev202410030339}/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