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

keras_hub/src/models/opt/opt_causal_lm_preprocessor.py

@@ -11,20 +11,14 @@
 # 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 absl import logging
-
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.models.opt.opt_preprocessor import OPTPreprocessor
-from keras_hub.src.utils.keras_utils import (
-    convert_inputs_to_list_of_tensor_segments,
-)
-from keras_hub.src.utils.tensor_utils import strip_to_ragged
+from keras_hub.src.models.causal_lm_preprocessor import CausalLMPreprocessor
+from keras_hub.src.models.opt.opt_backbone import OPTBackbone
+from keras_hub.src.models.opt.opt_tokenizer import OPTTokenizer
 
 
 @keras_hub_export("keras_hub.models.OPTCausalLMPreprocessor")
-class OPTCausalLMPreprocessor(OPTPreprocessor):
+class OPTCausalLMPreprocessor(CausalLMPreprocessor):
     """OPT Causal LM preprocessor.
 
     This preprocessing layer is primarily meant to be used with
@@ -92,86 +86,5 @@ class OPTCausalLMPreprocessor(OPTPreprocessor):
     ```
     """
 
-    def call(
-        self,
-        x,
-        y=None,
-        sample_weight=None,
-        sequence_length=None,
-    ):
-        if y is not None or sample_weight is not None:
-            logging.warning(
-                "`GPT2CausalLMPreprocessor` generates `y` and `sample_weight` "
-                "based on your input data, but your data already contains `y` "
-                "or `sample_weight`. Your `y` and `sample_weight` will be "
-                "ignored."
-            )
-        sequence_length = sequence_length or self.sequence_length
-
-        x = convert_inputs_to_list_of_tensor_segments(x)[0]
-        x = self.tokenizer(x)
-        # Pad with one extra token to account for the truncation below.
-        token_ids, padding_mask = self.packer(
-            x,
-            sequence_length=sequence_length + 1,
-            add_start_value=self.add_start_token,
-            add_end_value=self.add_end_token,
-        )
-        # The last token does not have a next token, so we truncate it out.
-        x = {
-            "token_ids": token_ids[..., :-1],
-            "padding_mask": padding_mask[..., :-1],
-        }
-        # Target `y` will be the next token.
-        y, sample_weight = token_ids[..., 1:], padding_mask[..., 1:]
-        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
-
-    def generate_preprocess(
-        self,
-        x,
-        sequence_length=None,
-    ):
-        """Convert strings to integer token input for generation.
-
-        Similar to calling the layer for training, this method takes in strings
-        or tensor strings, tokenizes and packs the input, and computes a padding
-        mask masking all inputs not filled in with a padded value.
-
-        Unlike calling the layer for training, this method does not compute
-        labels and will never append a `tokenizer.end_token_id` to the end of
-        the sequence (as generation is expected to continue at the end of the
-        inputted prompt).
-        """
-        if not self.built:
-            self.build(None)
-
-        x = convert_inputs_to_list_of_tensor_segments(x)[0]
-        x = self.tokenizer(x)
-        token_ids, padding_mask = self.packer(
-            x, sequence_length=sequence_length, add_end_value=False
-        )
-        return {
-            "token_ids": token_ids,
-            "padding_mask": padding_mask,
-        }
-
-    def generate_postprocess(
-        self,
-        x,
-    ):
-        """Convert integer token output to strings for generation.
-
-        This method reverses `generate_preprocess()`, by first removing all
-        padding and start/end tokens, and then converting the integer sequence
-        back to a string.
-        """
-        if not self.built:
-            self.build(None)
-
-        token_ids, padding_mask = x["token_ids"], x["padding_mask"]
-        ids_to_strip = (
-            self.tokenizer.end_token_id,
-            self.tokenizer.pad_token_id,
-        )
-        token_ids = strip_to_ragged(token_ids, padding_mask, ids_to_strip)
-        return self.tokenizer.detokenize(token_ids)
+    backbone_cls = OPTBackbone
+    tokenizer_cls = OPTTokenizer

keras_hub/src/models/opt/opt_preprocessor.py

@@ -17,11 +17,10 @@ import keras
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
+from keras_hub.src.models.opt.opt_backbone import OPTBackbone
 from keras_hub.src.models.opt.opt_tokenizer import OPTTokenizer
 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.utils.tensor_utils import preprocessing_function
 
 
 @keras_hub_export("keras_hub.models.OPTPreprocessor")
@@ -107,6 +106,7 @@ class OPTPreprocessor(Preprocessor):
     ```
     """
 
+    backbone_cls = OPTBackbone
     tokenizer_cls = OPTTokenizer
 
     def __init__(
@@ -148,6 +148,7 @@ class OPTPreprocessor(Preprocessor):
         )
         return config
 
+    @preprocessing_function
     def call(
         self,
         x,
@@ -155,17 +156,9 @@ class OPTPreprocessor(Preprocessor):
         sample_weight=None,
         sequence_length=None,
     ):
-        x = convert_inputs_to_list_of_tensor_segments(x)
-        if len(x) != 1:
-            raise ValueError(
-                "OPT requires each input feature to contain only "
-                f"one segment, but received {len(x)}. If you are using OPT "
-                "for a multi-segment classification task, please refer to "
-                "classification models like BERT or RoBERTa."
-            )
         sequence_length = sequence_length or self.sequence_length
         token_ids, padding_mask = self.packer(
-            self.tokenizer(x[0]),
+            self.tokenizer(x),
             sequence_length=sequence_length,
             add_start_value=self.add_start_token,
             add_end_value=self.add_end_token,

keras_hub/src/models/opt/opt_tokenizer.py

@@ -14,10 +14,16 @@
 
 
 from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.opt.opt_backbone import OPTBackbone
 from keras_hub.src.tokenizers.byte_pair_tokenizer import BytePairTokenizer
 
 
-@keras_hub_export("keras_hub.models.OPTTokenizer")
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.OPTTokenizer",
+        "keras_hub.models.OPTTokenizer",
+    ]
+)
 class OPTTokenizer(BytePairTokenizer):
     """An OPT tokenizer using Byte-Pair Encoding subword segmentation.
 
@@ -27,8 +33,6 @@ class OPTTokenizer(BytePairTokenizer):
     models and provides a `from_preset()` method to automatically download
     a matching vocabulary for a OPT preset.
 
-    This tokenizer does not provide truncation or padding of inputs.
-
     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.
     If input is a scalar string (rank == 0), the layer will output a dense
@@ -65,52 +69,19 @@ class OPTTokenizer(BytePairTokenizer):
     ```
     """
 
+    backbone_cls = OPTBackbone
+
     def __init__(
         self,
         vocabulary=None,
         merges=None,
         **kwargs,
     ):
-        self.start_token = "</s>"
-        self.pad_token = "<pad>"
-        self.end_token = "</s>"
-
+        self._add_special_token("</s>", "end_token")
+        self._add_special_token("</s>", "start_token")
+        self._add_special_token("<pad>", "pad_token")
         super().__init__(
             vocabulary=vocabulary,
             merges=merges,
-            unsplittable_tokens=[
-                self.start_token,
-                self.pad_token,
-                self.end_token,
-            ],
             **kwargs,
         )
-
-    def set_vocabulary_and_merges(self, vocabulary, merges):
-        super().set_vocabulary_and_merges(vocabulary, merges)
-
-        if vocabulary is not None:
-            # Check for necessary special tokens.
-            for token in [self.start_token, self.pad_token, self.end_token]:
-                if token not in self.vocabulary:
-                    raise ValueError(
-                        f"Cannot find token `'{token}'` in the provided "
-                        f"`vocabulary`. Please provide `'{token}'` in your "
-                        "`vocabulary` or use a pretrained `vocabulary` name."
-                    )
-
-            self.start_token_id = self.token_to_id(self.start_token)
-            self.pad_token_id = self.token_to_id(self.pad_token)
-            self.end_token_id = self.token_to_id(self.end_token)
-        else:
-            self.start_token_id = None
-            self.pad_token_id = None
-            self.end_token_id = None
-
-    def get_config(self):
-        config = super().get_config()
-        # In the constructor, we pass the list of special tokens to the
-        # `unsplittable_tokens` arg of the superclass' constructor. Hence, we
-        # delete it from the config here.
-        del config["unsplittable_tokens"]
-        return config

keras_hub/src/models/pali_gemma/__init__.py

@@ -15,9 +15,6 @@ from keras_hub.src.models.pali_gemma.pali_gemma_backbone import (
     PaliGemmaBackbone,
 )
 from keras_hub.src.models.pali_gemma.pali_gemma_presets import backbone_presets
-from keras_hub.src.models.pali_gemma.pali_gemma_tokenizer import (
-    PaliGemmaTokenizer,
-)
 from keras_hub.src.utils.preset_utils import register_presets
 
-register_presets(backbone_presets, (PaliGemmaBackbone, PaliGemmaTokenizer))
+register_presets(backbone_presets, PaliGemmaBackbone)

keras_hub/src/models/pali_gemma/pali_gemma_causal_lm_preprocessor.py

@@ -12,39 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import keras
-from absl import logging
-from keras import ops
 
 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.gemma.gemma_causal_lm_preprocessor import (
-    GemmaCausalLMPreprocessor,
+from keras_hub.src.models.causal_lm_preprocessor import CausalLMPreprocessor
+from keras_hub.src.models.pali_gemma.pali_gemma_backbone import (
+    PaliGemmaBackbone,
+)
+from keras_hub.src.models.pali_gemma.pali_gemma_image_converter import (
+    PaliGemmaImageConverter,
 )
 from keras_hub.src.models.pali_gemma.pali_gemma_tokenizer import (
     PaliGemmaTokenizer,
 )
-from keras_hub.src.utils.keras_utils import (
-    convert_inputs_to_list_of_tensor_segments,
-)
+from keras_hub.src.utils.tensor_utils import preprocessing_function
 
 
 @keras_hub_export("keras_hub.models.PaliGemmaCausalLMPreprocessor")
-class PaliGemmaCausalLMPreprocessor(GemmaCausalLMPreprocessor):
+class PaliGemmaCausalLMPreprocessor(CausalLMPreprocessor):
+    backbone_cls = PaliGemmaBackbone
     tokenizer_cls = PaliGemmaTokenizer
+    image_converter_cls = PaliGemmaImageConverter
 
     def __init__(
         self,
         tokenizer,
-        sequence_length=512,
+        image_converter=None,
+        sequence_length=1024,
         add_start_token=True,
         add_end_token=True,
         **kwargs,
     ):
         super().__init__(
-            tokenizer, sequence_length, add_start_token, add_end_token, **kwargs
+            tokenizer=tokenizer,
+            sequence_length=sequence_length,
+            add_start_token=add_start_token,
+            add_end_token=add_end_token,
+            **kwargs,
         )
+        self.image_converter = image_converter
 
     def build(self, input_shape):
         # Defer packer creation to `build()` so that we can be sure tokenizer
@@ -58,6 +66,7 @@ class PaliGemmaCausalLMPreprocessor(GemmaCausalLMPreprocessor):
         )
         self.built = True
 
+    @preprocessing_function
     def call(
         self,
         x,
@@ -65,23 +74,12 @@ class PaliGemmaCausalLMPreprocessor(GemmaCausalLMPreprocessor):
         sample_weight=None,
         sequence_length=None,
     ):
-        if y is not None or sample_weight is not None:
-            logging.warning(
-                "`PaliGemmaCausalLMPreprocessor` generates `y` and `sample_weight` "
-                "based on your input data, but your data already contains `y` "
-                "or `sample_weight`. Your `y` and `sample_weight` will be "
-                "ignored."
-            )
         sequence_length = sequence_length or self.sequence_length
-
         images, prompts, responses = x["images"], x["prompts"], x["responses"]
-        if keras.config.backend() == "tensorflow":
-            # Tensorflow backend needs uniform ouput types.
-            images = ops.convert_to_tensor(images)
-        prompts = convert_inputs_to_list_of_tensor_segments(prompts)[0]
         prompts = self.tokenizer(prompts)
-        responses = convert_inputs_to_list_of_tensor_segments(responses)[0]
         responses = self.tokenizer(responses)
+        if self.image_converter:
+            images = self.image_converter(images)
         # Pad with one extra token to account for the truncation below.
         token_ids, segment_ids = self.packer(
             (prompts, responses),
@@ -104,6 +102,7 @@ class PaliGemmaCausalLMPreprocessor(GemmaCausalLMPreprocessor):
         sample_weight = response_mask[..., 1:]
         return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
 
+    @preprocessing_function
     def generate_preprocess(
         self,
         x,
@@ -125,13 +124,14 @@ class PaliGemmaCausalLMPreprocessor(GemmaCausalLMPreprocessor):
         sequence_length = sequence_length or self.sequence_length
 
         images, prompts = x["images"], x["prompts"]
-        prompts = convert_inputs_to_list_of_tensor_segments(prompts)[0]
         prompts = self.tokenizer(prompts)
-        segments = [prompts]
+        if self.image_converter:
+            images = self.image_converter(images)
         if "responses" in x:
-            responses = x["responses"]
-            responses = convert_inputs_to_list_of_tensor_segments(responses)[0]
-            segments.append(self.tokenizer(responses))
+            responses = self.tokenizer(x["responses"])
+            segments = (prompts, responses)
+        else:
+            segments = (prompts,)
         token_ids, segment_ids = self.packer(
             segments,
             sequence_length=sequence_length,

keras_hub/src/models/pali_gemma/pali_gemma_image_converter.py

@@ -0,0 +1,25 @@
+# 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.pali_gemma.pali_gemma_backbone import (
+    PaliGemmaBackbone,
+)
+
+
+@keras_hub_export("keras_hub.layers.PaliGemmaImageConverter")
+class PaliGemmaImageConverter(ResizingImageConverter):
+    backbone_cls = PaliGemmaBackbone

keras_hub/src/models/pali_gemma/pali_gemma_presets.py

@@ -25,7 +25,7 @@ backbone_presets = {
             "path": "pali_gemma",
             "model_card": "https://www.kaggle.com/models/google/paligemma",
         },
-        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_mix_224/1",
+        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_mix_224/2",
     },
     "pali_gemma_3b_mix_448": {
         "metadata": {
@@ -37,7 +37,7 @@ backbone_presets = {
             "path": "pali_gemma",
             "model_card": "https://www.kaggle.com/models/google/paligemma",
         },
-        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_mix_448/1",
+        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_mix_448/2",
     },
     "pali_gemma_3b_224": {
         "metadata": {
@@ -49,7 +49,7 @@ backbone_presets = {
             "path": "pali_gemma",
             "model_card": "https://www.kaggle.com/models/google/paligemma",
         },
-        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_224/1",
+        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_224/2",
     },
     "pali_gemma_3b_448": {
         "metadata": {
@@ -61,7 +61,7 @@ backbone_presets = {
             "path": "pali_gemma",
             "model_card": "https://www.kaggle.com/models/google/paligemma",
         },
-        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_448/1",
+        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_448/2",
     },
     "pali_gemma_3b_896": {
         "metadata": {
@@ -73,6 +73,6 @@ backbone_presets = {
             "path": "pali_gemma",
             "model_card": "https://www.kaggle.com/models/google/paligemma",
         },
-        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_896/1",
+        "kaggle_handle": "kaggle://keras/paligemma/keras/pali_gemma_3b_896/2",
     },
 }

keras_hub/src/models/pali_gemma/pali_gemma_tokenizer.py

@@ -13,9 +13,17 @@
 # limitations under the License.
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.models.gemma.gemma_preprocessor import GemmaTokenizer
+from keras_hub.src.models.pali_gemma.pali_gemma_backbone import (
+    PaliGemmaBackbone,
+)
 
 
-@keras_hub_export("keras_hub.models.PaliGemmaTokenizer")
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.PaliGemmaTokenizer",
+        "keras_hub.models.PaliGemmaTokenizer",
+    ]
+)
 class PaliGemmaTokenizer(GemmaTokenizer):
     """PaliGemma tokenizer layer based on SentencePiece.
 
@@ -76,4 +84,4 @@ class PaliGemmaTokenizer(GemmaTokenizer):
     ```
     """
 
-    pass
+    backbone_cls = PaliGemmaBackbone

keras_hub/src/models/phi3/__init__.py

@@ -14,7 +14,6 @@
 
 from keras_hub.src.models.phi3.phi3_backbone import Phi3Backbone
 from keras_hub.src.models.phi3.phi3_presets import backbone_presets
-from keras_hub.src.models.phi3.phi3_tokenizer import Phi3Tokenizer
 from keras_hub.src.utils.preset_utils import register_presets
 
-register_presets(backbone_presets, (Phi3Backbone, Phi3Tokenizer))
+register_presets(backbone_presets, Phi3Backbone)

keras_hub/src/models/phi3/phi3_causal_lm.py

@@ -19,7 +19,6 @@ from keras_hub.src.models.phi3.phi3_backbone import Phi3Backbone
 from keras_hub.src.models.phi3.phi3_causal_lm_preprocessor import (
     Phi3CausalLMPreprocessor,
 )
-from keras_hub.src.utils.python_utils import classproperty
 from keras_hub.src.utils.tensor_utils import any_equal
 
 
@@ -46,6 +45,9 @@ class Phi3CausalLM(CausalLM):
             should be preprocessed before calling the model.
     """
 
+    backbone_cls = Phi3Backbone
+    preprocessor_cls = Phi3CausalLMPreprocessor
+
     def __init__(self, backbone, preprocessor=None, **kwargs):
         # === Layers ===
         self.backbone = backbone
@@ -61,14 +63,6 @@ class Phi3CausalLM(CausalLM):
             **kwargs,
         )
 
-    @classproperty
-    def backbone_cls(cls):
-        return Phi3Backbone
-
-    @classproperty
-    def preprocessor_cls(cls):
-        return Phi3CausalLMPreprocessor
-
     def call_with_cache(
         self,
         token_ids,

keras_hub/src/models/phi3/phi3_causal_lm_preprocessor.py

@@ -12,19 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import keras
-from absl import logging
-
 from keras_hub.src.api_export import keras_hub_export
-from keras_hub.src.models.phi3.phi3_preprocessor import Phi3Preprocessor
-from keras_hub.src.utils.keras_utils import (
-    convert_inputs_to_list_of_tensor_segments,
-)
-from keras_hub.src.utils.tensor_utils import strip_to_ragged
+from keras_hub.src.models.causal_lm_preprocessor import CausalLMPreprocessor
+from keras_hub.src.models.phi3.phi3_backbone import Phi3Backbone
+from keras_hub.src.models.phi3.phi3_tokenizer import Phi3Tokenizer
 
 
 @keras_hub_export("keras_hub.models.Phi3CausalLMPreprocessor")
-class Phi3CausalLMPreprocessor(Phi3Preprocessor):
+class Phi3CausalLMPreprocessor(CausalLMPreprocessor):
     """Phi3 Causal LM preprocessor.
 
     This preprocessing layer is meant for use with
@@ -91,83 +86,5 @@ class Phi3CausalLMPreprocessor(Phi3Preprocessor):
     ```
     """
 
-    def call(
-        self,
-        x,
-        y=None,
-        sample_weight=None,
-        sequence_length=None,
-    ):
-        if y is not None or sample_weight is not None:
-            logging.warning(
-                "`Phi3CausalLMPreprocessor` generates `y` and "
-                "`sample_weight` based on your input data, but your data "
-                "already contains `y` or `sample_weight`. Your `y` and "
-                "`sample_weight` will be ignored."
-            )
-        sequence_length = sequence_length or self.sequence_length
-
-        x = convert_inputs_to_list_of_tensor_segments(x)[0]
-        x = self.tokenizer(x)
-        # Pad with one extra token to account for the truncation below.
-        token_ids, padding_mask = self.packer(
-            x,
-            sequence_length=sequence_length + 1,
-            add_start_value=self.add_start_token,
-            add_end_value=self.add_end_token,
-        )
-        # The last token does not have a next token, so we truncate it out.
-        x = {
-            "token_ids": token_ids[..., :-1],
-            "padding_mask": padding_mask[..., :-1],
-        }
-        # Target `y` will be the next token.
-        y, sample_weight = token_ids[..., 1:], padding_mask[..., 1:]
-        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
-
-    def generate_preprocess(
-        self,
-        x,
-        sequence_length=None,
-    ):
-        """Convert strings to integer token input for generation.
-
-        Similar to calling the layer for training, this method takes in strings
-        or tensor strings, tokenizes and packs the input, and computes a padding
-        mask masking all inputs not filled in with a padded value.
-
-        Unlike calling the layer for training, this method does not compute
-        labels and will never append a `tokenizer.end_token_id` to the end of
-        the sequence (as generation is expected to continue at the end of the
-        inputted prompt).
-        """
-        if not self.built:
-            self.build(None)
-
-        x = convert_inputs_to_list_of_tensor_segments(x)[0]
-        x = self.tokenizer(x)
-        token_ids, padding_mask = self.packer(
-            x, sequence_length=sequence_length, add_end_value=False
-        )
-        return {
-            "token_ids": token_ids,
-            "padding_mask": padding_mask,
-        }
-
-    def generate_postprocess(
-        self,
-        x,
-    ):
-        """Convert integer token output to strings for generation.
-
-        This method reverses `generate_preprocess()`, by first removing all
-        padding and start/end tokens, and then converting the integer sequence
-        back to a string.
-        """
-        token_ids, padding_mask = x["token_ids"], x["padding_mask"]
-        ids_to_strip = (
-            self.tokenizer.start_token_id,
-            self.tokenizer.end_token_id,
-        )
-        token_ids = strip_to_ragged(token_ids, padding_mask, ids_to_strip)
-        return self.tokenizer.detokenize(token_ids)
+    backbone_cls = Phi3Backbone
+    tokenizer_cls = Phi3Tokenizer

keras_hub/src/models/phi3/phi3_preprocessor.py

@@ -15,11 +15,10 @@ import keras
 
 from keras_hub.src.api_export import keras_hub_export
 from keras_hub.src.layers.preprocessing.start_end_packer import StartEndPacker
+from keras_hub.src.models.phi3.phi3_backbone import Phi3Backbone
 from keras_hub.src.models.phi3.phi3_tokenizer import Phi3Tokenizer
 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.utils.tensor_utils import preprocessing_function
 
 
 @keras_hub_export("keras_hub.models.Phi3Preprocessor")
@@ -110,6 +109,7 @@ class Phi3Preprocessor(Preprocessor):
     ```
     """
 
+    backbone_cls = Phi3Backbone
     tokenizer_cls = Phi3Tokenizer
 
     def __init__(
@@ -150,6 +150,7 @@ class Phi3Preprocessor(Preprocessor):
         )
         return config
 
+    @preprocessing_function
     def call(
         self,
         x,
@@ -157,17 +158,9 @@ class Phi3Preprocessor(Preprocessor):
         sample_weight=None,
         sequence_length=None,
     ):
-        x = convert_inputs_to_list_of_tensor_segments(x)
-        if len(x) != 1:
-            raise ValueError(
-                "Phi3 requires each input feature to contain only "
-                f"one segment, but received {len(x)}. If you are using Phi3"
-                " for a multi-segment classification task, please refer to "
-                "classification models like BERT or RoBERTa."
-            )
         sequence_length = sequence_length or self.sequence_length
         token_ids, padding_mask = self.packer(
-            self.tokenizer(x[0]),
+            self.tokenizer(x),
             sequence_length=sequence_length,
             add_start_value=self.add_start_token,
             add_end_value=self.add_end_token,