keras-hub-nightly 0.15.0.dev20240823171555__py3-none-any.whl → 0.15.0.dev20240911134614__py3-none-any.whl

keras_hub/src/models/distil_bert/{distil_bert_preprocessor.py → distil_bert_text_classifier_preprocessor.py}

@@ -16,20 +16,25 @@
 import keras
 
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.layers.preprocessing.multi_segment_packer import (
-    MultiSegmentPacker,
+from keras_hub.src.models.distil_bert.distil_bert_backbone import (
+    DistilBertBackbone,
 )
 from keras_hub.src.models.distil_bert.distil_bert_tokenizer import (
     DistilBertTokenizer,
 )
-from keras_hub.src.models.preprocessor import Preprocessor
-from keras_hub.src.utils.keras_utils import (
-    convert_inputs_to_list_of_tensor_segments,
+from keras_hub.src.models.text_classifier_preprocessor import (
+    TextClassifierPreprocessor,
 )
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
-@keras_hub_export("keras_hub.models.DistilBertPreprocessor")
-class DistilBertPreprocessor(Preprocessor):
+@keras_hub_export(
+    [
+        "keras_hub.models.DistilBertTextClassifierPreprocessor",
+        "keras_hub.models.DistilBertPreprocessor",
+    ]
+)
+class DistilBertTextClassifierPreprocessor(TextClassifierPreprocessor):
     """A DistilBERT preprocessing layer which tokenizes and packs inputs.
 
     This preprocessing layer will do three things:
@@ -70,7 +75,7 @@ class DistilBertPreprocessor(Preprocessor):
 
     Directly calling the layer on data.
     ```python
-    preprocessor = keras_hub.models.DistilBertPreprocessor.from_preset(
+    preprocessor = keras_hub.models.TextClassifierPreprocessor.from_preset(
         "distil_bert_base_en_uncased"
     )
     preprocessor(["The quick brown fox jumped.", "Call me Ishmael."])
@@ -79,13 +84,15 @@ class DistilBertPreprocessor(Preprocessor):
     vocab = ["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"]
     vocab += ["The", "quick", "brown", "fox", "jumped", "."]
     tokenizer = keras_hub.models.DistilBertTokenizer(vocabulary=vocab)
-    preprocessor = keras_hub.models.DistilBertPreprocessor(tokenizer)
+    preprocessor = keras_hub.models.DistilBertTextClassifierPreprocessor(
+        tokenizer
+    )
     preprocessor("The quick brown fox jumped.")
     ```
 
     Mapping with `tf.data.Dataset`.
     ```python
-    preprocessor = keras_hub.models.DistilBertPreprocessor.from_preset(
+    preprocessor = keras_hub.models.TextClassifierPreprocessor.from_preset(
         "distil_bert_base_en_uncased"
     )
 
@@ -116,60 +123,13 @@ class DistilBertPreprocessor(Preprocessor):
     ```
     """
 
+    backbone_cls = DistilBertBackbone
     tokenizer_cls = DistilBertTokenizer
 
-    def __init__(
-        self,
-        tokenizer,
-        sequence_length=512,
-        truncate="round_robin",
-        **kwargs,
-    ):
-        super().__init__(**kwargs)
-        self.tokenizer = tokenizer
-        self.packer = None
-        self.sequence_length = sequence_length
-        self.truncate = truncate
-
-    def build(self, input_shape):
-        super().build(input_shape)
-        # Defer masker creation to `build()` so that we can be sure tokenizer
-        # assets have loaded when restoring a saved model.
-        self.packer = MultiSegmentPacker(
-            start_value=self.tokenizer.cls_token_id,
-            end_value=self.tokenizer.sep_token_id,
-            pad_value=self.tokenizer.pad_token_id,
-            truncate=self.truncate,
-            sequence_length=self.sequence_length,
-        )
-
+    @preprocessing_function
     def call(self, x, y=None, sample_weight=None):
-        x = convert_inputs_to_list_of_tensor_segments(x)
-        x = [self.tokenizer(segment) for segment in x]
-        token_ids, _ = self.packer(x)
-        x = {
-            "token_ids": token_ids,
-            "padding_mask": token_ids != self.tokenizer.pad_token_id,
-        }
+        output = super().call(x, y=y, sample_weight=sample_weight)
+        x, y, sample_weight = keras.utils.unpack_x_y_sample_weight(output)
+        # Backbone has no segment ID input.
+        del x["segment_ids"]
         return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
-
-    def get_config(self):
-        config = super().get_config()
-        config.update(
-            {
-                "sequence_length": self.sequence_length,
-                "truncate": self.truncate,
-            }
-        )
-        return config
-
-    @property
-    def sequence_length(self):
-        """The padded length of model input sequences."""
-        return self._sequence_length
-
-    @sequence_length.setter
-    def sequence_length(self, value):
-        self._sequence_length = value
-        if self.packer is not None:
-            self.packer.sequence_length = value

keras_hub/src/models/distil_bert/distil_bert_tokenizer.py

@@ -14,10 +14,18 @@
 
 
 from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.distil_bert.distil_bert_backbone import (
+    DistilBertBackbone,
+)
 from keras_hub.src.tokenizers.word_piece_tokenizer import WordPieceTokenizer
 
 
-@keras_hub_export("keras_hub.models.DistilBertTokenizer")
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.DistilBertTokenizer",
+        "keras_hub.models.DistilBertTokenizer",
+    ]
+)
 class DistilBertTokenizer(WordPieceTokenizer):
     """A DistilBERT tokenizer using WordPiece subword segmentation.
 
@@ -27,9 +35,6 @@ class DistilBertTokenizer(WordPieceTokenizer):
     models and provides a `from_preset()` method to automatically download
     a matching vocabulary for a DistilBERT preset.
 
-    This tokenizer does not provide truncation or padding of inputs. It can be
-    combined with a `keras_hub.models.DistilBertPreprocessor` layer for input packing.
-
     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.
 
@@ -70,45 +75,24 @@ class DistilBertTokenizer(WordPieceTokenizer):
     ```
     """
 
+    backbone_cls = DistilBertBackbone
+
     def __init__(
         self,
         vocabulary,
         lowercase=False,
-        special_tokens_in_strings=False,
         **kwargs,
     ):
-        self.cls_token = "[CLS]"
-        self.sep_token = "[SEP]"
-        self.pad_token = "[PAD]"
-        self.mask_token = "[MASK]"
+        self._add_special_token("[CLS]", "cls_token")
+        self._add_special_token("[SEP]", "sep_token")
+        self._add_special_token("[PAD]", "pad_token")
+        self._add_special_token("[MASK]", "mask_token")
+        # Also add `tokenizer.start_token` and `tokenizer.end_token` for
+        # compatibility with other tokenizers.
+        self._add_special_token("[CLS]", "start_token")
+        self._add_special_token("[SEP]", "end_token")
         super().__init__(
             vocabulary=vocabulary,
             lowercase=lowercase,
-            special_tokens=[
-                self.cls_token,
-                self.sep_token,
-                self.pad_token,
-                self.mask_token,
-            ],
-            special_tokens_in_strings=special_tokens_in_strings,
             **kwargs,
         )
-
-    def set_vocabulary(self, vocabulary):
-        super().set_vocabulary(vocabulary)
-
-        if vocabulary is not None:
-            self.cls_token_id = self.token_to_id(self.cls_token)
-            self.sep_token_id = self.token_to_id(self.sep_token)
-            self.pad_token_id = self.token_to_id(self.pad_token)
-            self.mask_token_id = self.token_to_id(self.mask_token)
-        else:
-            self.cls_token_id = None
-            self.sep_token_id = None
-            self.pad_token_id = None
-            self.mask_token_id = None
-
-    def get_config(self):
-        config = super().get_config()
-        del config["special_tokens"]  # Not configurable; set in __init__.
-        return config

keras_hub/src/models/efficientnet/__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.