keras-hub-nightly 0.16.1.dev202410020340__py3-none-any.whl → 0.19.0.dev202501260345__py3-none-any.whl

keras_hub/src/models/densenet/densenet_image_classifier.py

@@ -1,8 +1,6 @@
-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 (
+from keras_hub.src.models.densenet.densenet_image_classifier_preprocessor import (  # noqa: E501
     DenseNetImageClassifierPreprocessor,
 )
 from keras_hub.src.models.image_classifier import ImageClassifier
@@ -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/densenet/densenet_presets.py

@@ -4,40 +4,34 @@ backbone_presets = {
     "densenet_121_imagenet": {
         "metadata": {
             "description": (
-                "121-layer DenseNet model pre-trained on the ImageNet 1k dataset "
-                "at a 224x224 resolution."
+                "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",
+        "kaggle_handle": "kaggle://keras/densenet/keras/densenet_121_imagenet/3",
     },
     "densenet_169_imagenet": {
         "metadata": {
             "description": (
-                "169-layer DenseNet model pre-trained on the ImageNet 1k dataset "
-                "at a 224x224 resolution."
+                "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",
+        "kaggle_handle": "kaggle://keras/densenet/keras/densenet_169_imagenet/3",
     },
     "densenet_201_imagenet": {
         "metadata": {
             "description": (
-                "201-layer DenseNet model pre-trained on the ImageNet 1k dataset "
-                "at a 224x224 resolution."
+                "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",
+        "kaggle_handle": "kaggle://keras/densenet/keras/densenet_201_imagenet/3",
     },
 }

keras_hub/src/models/distil_bert/distil_bert_masked_lm.py

@@ -8,7 +8,7 @@ from keras_hub.src.models.distil_bert.distil_bert_backbone import (
 from keras_hub.src.models.distil_bert.distil_bert_backbone import (
     distilbert_kernel_initializer,
 )
-from keras_hub.src.models.distil_bert.distil_bert_masked_lm_preprocessor import (
+from keras_hub.src.models.distil_bert.distil_bert_masked_lm_preprocessor import (  # noqa: E501
     DistilBertMaskedLMPreprocessor,
 )
 from keras_hub.src.models.masked_lm import MaskedLM

keras_hub/src/models/distil_bert/distil_bert_masked_lm_preprocessor.py

@@ -17,8 +17,8 @@ class DistilBertMaskedLMPreprocessor(MaskedLMPreprocessor):
 
     This preprocessing layer will prepare inputs for a masked language modeling
     task. It is primarily intended for use with the
-    `keras_hub.models.DistilBertMaskedLM` task model. Preprocessing will occur in
-    multiple steps.
+    `keras_hub.models.DistilBertMaskedLM` task model. Preprocessing will occur
+    in multiple steps.
 
     1. Tokenize any number of input segments using the `tokenizer`.
     2. Pack the inputs together using a `keras_hub.layers.MultiSegmentPacker`.

keras_hub/src/models/distil_bert/distil_bert_presets.py

@@ -9,11 +9,9 @@ backbone_presets = {
                 "teacher model."
             ),
             "params": 66362880,
-            "official_name": "DistilBERT",
             "path": "distil_bert",
-            "model_card": "https://huggingface.co/distilbert-base-uncased",
         },
-        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_en_uncased/2",
+        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_en_uncased/3",
     },
     "distil_bert_base_en": {
         "metadata": {
@@ -23,22 +21,19 @@ backbone_presets = {
                 "teacher model."
             ),
             "params": 65190912,
-            "official_name": "DistilBERT",
             "path": "distil_bert",
-            "model_card": "https://huggingface.co/distilbert-base-cased",
         },
-        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_en/2",
+        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_en/3",
     },
     "distil_bert_base_multi": {
         "metadata": {
             "description": (
-                "6-layer DistilBERT model where case is maintained. Trained on Wikipedias of 104 languages"
+                "6-layer DistilBERT model where case is maintained. Trained on "
+                "Wikipedias of 104 languages"
             ),
             "params": 134734080,
-            "official_name": "DistilBERT",
             "path": "distil_bert",
-            "model_card": "https://huggingface.co/distilbert-base-multilingual-cased",
         },
-        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_multi/2",
+        "kaggle_handle": "kaggle://keras/distil_bert/keras/distil_bert_base_multi/3",
     },
 }

keras_hub/src/models/distil_bert/distil_bert_text_classifier.py

@@ -7,7 +7,7 @@ from keras_hub.src.models.distil_bert.distil_bert_backbone import (
 from keras_hub.src.models.distil_bert.distil_bert_backbone import (
     distilbert_kernel_initializer,
 )
-from keras_hub.src.models.distil_bert.distil_bert_text_classifier_preprocessor import (
+from keras_hub.src.models.distil_bert.distil_bert_text_classifier_preprocessor import (  # noqa: E501
     DistilBertTextClassifierPreprocessor,
 )
 from keras_hub.src.models.text_classifier import TextClassifier
@@ -40,9 +40,9 @@ class DistilBertTextClassifier(TextClassifier):
     Args:
         backbone: A `keras_hub.models.DistilBert` instance.
         num_classes: int. Number of classes to predict.
-        preprocessor: A `keras_hub.models.DistilBertTextClassifierPreprocessor` or `None`. If
-            `None`, this model will not apply preprocessing, and inputs should
-            be preprocessed before calling the model.
+        preprocessor: A `keras_hub.models.DistilBertTextClassifierPreprocessor`
+            or `None`. If `None`, this model will not apply preprocessing, and
+            inputs should be preprocessed before calling the model.
         activation: Optional `str` or callable. The
             activation function to use on the model outputs. Set
             `activation="softmax"` to return output probabilities.
@@ -128,7 +128,7 @@ class DistilBertTextClassifier(TextClassifier):
     )
     classifier.fit(x=features, y=labels, batch_size=2)
     ```
-    """
+    """  # noqa: E501
 
     backbone_cls = DistilBertBackbone
     preprocessor_cls = DistilBertTextClassifierPreprocessor

keras_hub/src/models/distil_bert/distil_bert_tokenizer.py

@@ -16,9 +16,9 @@ class DistilBertTokenizer(WordPieceTokenizer):
 
     This tokenizer class will tokenize raw strings into integer sequences and
     is based on `keras_hub.tokenizers.WordPieceTokenizer`. Unlike the
-    underlying tokenizer, it will check for all special tokens needed by DistilBERT
-    models and provides a `from_preset()` method to automatically download
-    a matching vocabulary for a DistilBERT preset.
+    underlying tokenizer, it will check for all special tokens needed by
+    DistilBERT models and provides a `from_preset()` method to automatically
+    download a matching vocabulary for a DistilBERT preset.
 
     If input is a batch of strings (rank > 0), the layer will output a
     `tf.RaggedTensor` where the last dimension of the output is ragged.

keras_hub/src/models/efficientnet/__init__.py

@@ -0,0 +1,9 @@
+from keras_hub.src.models.efficientnet.efficientnet_backbone import (
+    EfficientNetBackbone,
+)
+from keras_hub.src.models.efficientnet.efficientnet_presets import (
+    backbone_presets,
+)
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, EfficientNetBackbone)

keras_hub/src/models/efficientnet/cba.py

@@ -0,0 +1,141 @@
+import keras
+
+BN_AXIS = 3
+
+
+class CBABlock(keras.layers.Layer):
+    """
+    Args:
+        input_filters: int, the number of input filters
+        output_filters: int, the number of output filters
+        kernel_size: default 3, the kernel_size to apply to the expansion phase
+            convolutions
+        strides: default 1, the strides to apply to the expansion phase
+            convolutions
+        data_format: str, channels_last (default) or channels_first, expects
+            tensors to be of shape (N, H, W, C) or (N, C, H, W) respectively
+        batch_norm_momentum: default 0.9, the BatchNormalization momentum
+        batch_norm_epsilon: default 1e-3, the BatchNormalization epsilon
+        activation: default "swish", the activation function used between
+            convolution operations
+        dropout: float, the optional dropout rate to apply before the output
+            convolution, defaults to 0.2
+        nores: bool, default False, forces no residual connection if True,
+            otherwise allows it if False.
+
+    Returns:
+        A tensor representing a feature map, passed through the ConvBNAct
+        block
+
+    Note:
+        Not intended to be used outside of the EfficientNet architecture.
+    """
+
+    def __init__(
+        self,
+        input_filters,
+        output_filters,
+        kernel_size=3,
+        strides=1,
+        data_format="channels_last",
+        batch_norm_momentum=0.9,
+        batch_norm_epsilon=1e-3,
+        activation="swish",
+        dropout=0.2,
+        nores=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.input_filters = input_filters
+        self.output_filters = output_filters
+        self.kernel_size = kernel_size
+        self.strides = strides
+        self.data_format = data_format
+        self.batch_norm_momentum = batch_norm_momentum
+        self.batch_norm_epsilon = batch_norm_epsilon
+        self.activation = activation
+        self.dropout = dropout
+        self.nores = nores
+
+        padding_pixels = kernel_size // 2
+        self.conv1_pad = keras.layers.ZeroPadding2D(
+            padding=(padding_pixels, padding_pixels),
+            name=self.name + "conv_pad",
+        )
+        self.conv1 = keras.layers.Conv2D(
+            filters=self.output_filters,
+            kernel_size=kernel_size,
+            strides=strides,
+            kernel_initializer=self._conv_kernel_initializer(),
+            padding="valid",
+            data_format=data_format,
+            use_bias=False,
+            name=self.name + "conv",
+        )
+        self.bn1 = keras.layers.BatchNormalization(
+            axis=BN_AXIS,
+            momentum=self.batch_norm_momentum,
+            epsilon=self.batch_norm_epsilon,
+            name=self.name + "bn",
+        )
+        self.act = keras.layers.Activation(
+            self.activation, name=self.name + "activation"
+        )
+
+        if self.dropout:
+            self.dropout_layer = keras.layers.Dropout(
+                self.dropout,
+                noise_shape=(None, 1, 1, 1),
+                name=self.name + "drop",
+            )
+
+    def _conv_kernel_initializer(
+        self,
+        scale=2.0,
+        mode="fan_out",
+        distribution="truncated_normal",
+        seed=None,
+    ):
+        return keras.initializers.VarianceScaling(
+            scale=scale, mode=mode, distribution=distribution, seed=seed
+        )
+
+    def build(self, input_shape):
+        if self.name is None:
+            self.name = keras.backend.get_uid("block0")
+
+    def call(self, inputs):
+        x = self.conv1_pad(inputs)
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.act(x)
+
+        # Residual:
+        if (
+            self.strides == 1
+            and self.input_filters == self.output_filters
+            and not self.nores
+        ):
+            if self.dropout:
+                x = self.dropout_layer(x)
+            x = keras.layers.Add(name=self.name + "add")([x, inputs])
+        return x
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "input_filters": self.input_filters,
+                "output_filters": self.output_filters,
+                "kernel_size": self.kernel_size,
+                "strides": self.strides,
+                "data_format": self.data_format,
+                "batch_norm_momentum": self.batch_norm_momentum,
+                "batch_norm_epsilon": self.batch_norm_epsilon,
+                "activation": self.activation,
+                "dropout": self.dropout,
+                "nores": self.nores,
+            }
+        )
+
+        return config