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

keras_hub/src/models/phi3/phi3_preprocessor.py

@@ -0,0 +1,190 @@
+# 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.
+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_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,
+)
+
+
+@keras_hub_export("keras_hub.models.Phi3Preprocessor")
+class Phi3Preprocessor(Preprocessor):
+    """A Phi3 preprocessing layer which tokenizes and packs inputs.
+
+    This preprocessing layer will do three things:
+
+     1. Tokenize any number of input segments using the `tokenizer`.
+     2. Pack the inputs together using a `keras_hub.layers.StartEndPacker`.
+       with the appropriate tokens.
+     3. Construct a dictionary with keys `"token_ids"`, and `"padding_mask"`
+       that can be passed directly to `keras_hub.models.Phi3Backbone`.
+
+    This layer can be used directly with `tf.data.Dataset.map` to preprocess
+    string data in the `(x, y, sample_weight)` format used by
+    `keras.Model.fit`.
+
+    Args:
+        tokenizer: A `keras_hub.models.Phi3Tokenizer` instance.
+        sequence_length: The length of the packed inputs.
+        add_start_token: If `True`, the preprocessor will prepend the tokenizer
+            start token to each input sequence. Default is `True`.
+        add_end_token: If `True`, the preprocessor will append the tokenizer
+            end token to each input sequence. Default is `False`.
+
+    Call arguments:
+        x: A tensor of single string sequences, or a tuple of multiple
+            tensor sequences to be packed together. Inputs may be batched or
+            unbatched. For single sequences, raw python inputs will be converted
+            to tensors. For multiple sequences, pass tensors directly.
+        y: Any label data. Will be passed through unaltered.
+        sample_weight: Any label weight data. Will be passed through unaltered.
+        sequence_length: Pass to override the configured `sequence_length` of
+            the layer.
+
+    Examples:
+
+    Directly calling the from_preset().
+    ```python
+    preprocessor = keras_hub.models.Phi3Preprocessor.from_preset(
+        ""
+    )
+
+    # Tokenize and pack a single sentence.
+    preprocessor("The quick brown fox jumped.")
+
+    # Tokenize and a batch of single sentences.
+    preprocessor(["The quick brown fox jumped.", "Call me Ishmael."])
+
+    # Preprocess a batch of sentence pairs.
+    # When handling multiple sequences, always convert to tensors first!
+    first = tf.constant(["The quick brown fox jumped.", "Call me Ishmael."])
+    second = tf.constant(["The fox tripped.", "Oh look, a whale."])
+    preprocessor((first, second))
+    ```
+
+    Mapping with `tf.data.Dataset`.
+    ```python
+    preprocessor = keras_hub.models.Phi3Preprocessor.from_preset(
+        "phi3_mini_4k_instruct_en"
+    )
+    first = tf.constant(["The quick brown fox jumped.", "Call me Ishmael."])
+    second = tf.constant(["The fox tripped.", "Oh look, a whale."])
+    label = tf.constant([1, 1])
+
+    # Map labeled single sentences.
+    ds = tf.data.Dataset.from_tensor_slices((first, label))
+    ds = ds.map(preprocessor, num_parallel_calls=tf.data.AUTOTUNE)
+
+    # Map unlabeled single sentences.
+    ds = tf.data.Dataset.from_tensor_slices(first)
+    ds = ds.map(preprocessor, num_parallel_calls=tf.data.AUTOTUNE)
+
+    # Map labeled sentence pairs.
+    ds = tf.data.Dataset.from_tensor_slices(((first, second), label))
+    ds = ds.map(preprocessor, num_parallel_calls=tf.data.AUTOTUNE)
+
+    # Map unlabeled sentence pairs.
+    ds = tf.data.Dataset.from_tensor_slices((first, second))
+
+    # Watch out for tf.data's default unpacking of tuples here!
+    # Best to invoke the `preprocessor` directly in this case.
+    ds = ds.map(
+        lambda first, second: preprocessor(x=(first, second)),
+        num_parallel_calls=tf.data.AUTOTUNE,
+    )
+    ```
+    """
+
+    tokenizer_cls = Phi3Tokenizer
+
+    def __init__(
+        self,
+        tokenizer,
+        sequence_length=1024,
+        add_start_token=True,
+        add_end_token=False,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+        self.tokenizer = tokenizer
+        self.packer = None
+        self.add_start_token = add_start_token
+        self.add_end_token = add_end_token
+        self.sequence_length = sequence_length
+
+    def build(self, input_shape):
+        # Defer packer creation to `build()` so that we can be sure tokenizer
+        # assets have loaded when restoring a saved model.
+        self.packer = StartEndPacker(
+            start_value=self.tokenizer.start_token_id,
+            end_value=self.tokenizer.end_token_id,
+            pad_value=self.tokenizer.pad_token_id,
+            sequence_length=self.sequence_length,
+            return_padding_mask=True,
+        )
+        self.built = True
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "sequence_length": self.sequence_length,
+                "add_start_token": self.add_start_token,
+                "add_end_token": self.add_end_token,
+            }
+        )
+        return config
+
+    def call(
+        self,
+        x,
+        y=None,
+        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]),
+            sequence_length=sequence_length,
+            add_start_value=self.add_start_token,
+            add_end_value=self.add_end_token,
+        )
+        x = {
+            "token_ids": token_ids,
+            "padding_mask": padding_mask,
+        }
+        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
+
+    @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/phi3/phi3_presets.py

@@ -0,0 +1,50 @@
+# 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.
+"""Phi-3 model preset configurations."""
+
+# Metadata for loading pretrained model weights.
+backbone_presets = {
+    "phi3_mini_4k_instruct_en": {
+        "metadata": {
+            "description": (
+                "3.8 billion parameters, 32 layers, 4k context length, Phi-3 "
+                "model. The model was trained using the Phi-3 datasets. This "
+                "dataset includes both synthetic data and filtered publicly "
+                "available website data, with an emphasis on high-quality and "
+                "reasoning-dense properties."
+            ),
+            "params": 3821079552,
+            "official_name": "Phi-3",
+            "path": "phi3",
+            "model_card": "https://huggingface.co/microsoft/Phi-3-mini-4k-instruct",
+        },
+        "kaggle_handle": "kaggle://keras/phi3/keras/phi3_mini_4k_instruct_en",
+    },
+    "phi3_mini_128k_instruct_en": {
+        "metadata": {
+            "description": (
+                "3.8 billion parameters, 32 layers, 128k context length, Phi-3 "
+                "model. The model was trained using the Phi-3 datasets. This "
+                "dataset includes both synthetic data and filtered publicly "
+                "available website data, with an emphasis on high-quality and "
+                "reasoning-dense properties."
+            ),
+            "params": 3821079552,
+            "official_name": "Phi-3",
+            "path": "phi3",
+            "model_card": "https://huggingface.co/microsoft/Phi-3-mini-128k-instruct",
+        },
+        "kaggle_handle": "kaggle://keras/phi3/keras/phi3_mini_128k_instruct_en",
+    },
+}

keras_hub/src/models/phi3/phi3_rotary_embedding.py

@@ -0,0 +1,137 @@
+# 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.
+import math
+
+from keras import ops
+
+from keras_hub.src.layers.modeling.rotary_embedding import RotaryEmbedding
+
+
+class Phi3SuScaledRotaryEmbedding(RotaryEmbedding):
+    """SuRotary positional encoding layer.
+
+    Args:
+        inverese_freq_short_factor List[float]: List of factors used to adjust
+            rope frequencies when the `rope_scaling_type` is `"su"`. List must
+            be of length `hidden_dim//num_query_heads//2`. It is used when
+            `sequence_length` is smaller than `original_max_sequence_length`.
+        inverese_freq_long_factor List[float]: List of factors used to adjust
+            rope frequencies when the `rope_scaling_type` is `"su"`. List must
+            be of length `hidden_dim//num_query_heads//2`. It is used when
+            `sequence_length` is larger than `original_max_sequence_length`.
+        max_sequence_length: int. The maximum sequence length that this
+            model might ever be used with.
+        pretraining_sequence_length: int. The maximum sequence length that
+            this model was pretrained with.
+        max_wavelength: int. The maximum angular wavelength of the sine/cosine
+            curves.
+
+    Call arguments:
+        inputs: The tensor inputs to apply the embedding to. This can have
+            any shape, but must contain both a sequence and feature axis. The
+            rotary embedding will be applied to `inputs` and returned.
+        start_index: An integer or integer tensor. The starting position to
+            compute the rotary embedding from. This is useful during cached
+            decoding, where each position is predicted separately in a loop.
+
+    References:
+     - [Phi-3-mini-128k-instruct original implementation](https://huggingface.co/microsoft/Phi-3-mini-128k-instruct/blob/0693e0b867d29e7318280ddd3ff9d5e66698f488/modeling_phi3.py#L142)
+    """
+
+    def __init__(
+        self,
+        inverese_freq_short_factor,
+        inverese_freq_long_factor,
+        max_sequence_length=4096,
+        pretraining_sequence_length=4096,
+        max_wavelength=10000,
+        **kwargs
+    ):
+        super().__init__(max_wavelength=max_wavelength, **kwargs)
+        self.max_sequence_length = max_sequence_length
+        self.pretraining_sequence_length = pretraining_sequence_length
+
+        scaling_factor = (
+            self.max_sequence_length / self.pretraining_sequence_length
+        )
+        if scaling_factor <= 1.0:
+            self.embedding_scaling_factor = 1.0
+        else:
+            self.embedding_scaling_factor = math.sqrt(
+                1
+                + math.log(scaling_factor)
+                / math.log(self.pretraining_sequence_length)
+            )
+
+        self.inverese_freq_short_factor = inverese_freq_short_factor
+        self.inverese_freq_long_factor = inverese_freq_long_factor
+
+    def _compute_cos_sin_embedding(self, inputs, start_index=0, positions=None):
+        feature_axis = len(inputs.shape) - 1
+        sequence_axis = 1
+
+        rotary_dim = ops.shape(inputs)[feature_axis]
+        inverse_freq = self._get_inverse_freq(rotary_dim)
+
+        # Multiply inverse_freq by a factor.
+        if ops.shape(inputs)[sequence_axis] > self.pretraining_sequence_length:
+            inverse_freq = ops.divide(
+                inverse_freq,
+                ops.convert_to_tensor(self.inverese_freq_long_factor),
+            )
+        else:
+            inverse_freq = ops.divide(
+                inverse_freq,
+                ops.convert_to_tensor(self.inverese_freq_short_factor),
+            )
+
+        if positions is None:
+            positions = self._compute_positions(inputs, start_index)
+        else:
+            positions = ops.cast(positions, "float32")
+
+        freq = ops.einsum("i,j->ij", positions, inverse_freq)
+        embedding = ops.stack((freq, freq), axis=-2)
+        embedding = ops.reshape(
+            embedding, (*ops.shape(freq)[:-1], ops.shape(freq)[-1] * 2)
+        )
+
+        # Reshape the embedding to be broadcastable with input shape.
+        if feature_axis < sequence_axis:
+            embedding = ops.transpose(embedding)
+        for axis in range(len(inputs.shape)):
+            if axis != sequence_axis and axis != feature_axis:
+                embedding = ops.expand_dims(embedding, axis)
+
+        cos_emb = ops.cast(
+            ops.cos(embedding) * self.embedding_scaling_factor,
+            self.compute_dtype,
+        )
+        sin_emb = ops.cast(
+            ops.sin(embedding) * self.embedding_scaling_factor,
+            self.compute_dtype,
+        )
+        return cos_emb, sin_emb
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "max_sequence_length": self.max_sequence_length,
+                "pretraining_sequence_length": self.pretraining_sequence_length,
+                "inverese_freq_short_factor": self.inverese_freq_short_factor,
+                "inverese_freq_long_factor": self.inverese_freq_long_factor,
+            }
+        )
+        return config

keras_hub/src/models/phi3/phi3_tokenizer.py

@@ -0,0 +1,94 @@
+# 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.
+import copy
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.phi3.phi3_presets import backbone_presets
+from keras_hub.src.tokenizers.sentence_piece_tokenizer import (
+    SentencePieceTokenizer,
+)
+from keras_hub.src.utils.python_utils import classproperty
+
+
+@keras_hub_export("keras_hub.models.Phi3Tokenizer")
+class Phi3Tokenizer(SentencePieceTokenizer):
+    """Phi3 tokenizer layer based on SentencePiece.
+
+    This tokenizer class will tokenize raw strings into integer sequences and
+    is based on `keras_hub.tokenizers.SentencePieceTokenizer`. Unlike the
+    underlying tokenizer, it will check for all special tokens needed by
+    Phi3 models and provides a `from_preset()` method to automatically
+    download a matching vocabulary for a Phi3 preset.
+
+    This tokenizer does not provide truncation or padding of inputs. It can be
+    combined with a `keras_hub.models.Phi3Preprocessor` 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.
+
+    If input is a scalar string (rank == 0), the layer will output a dense
+    `tf.Tensor` with static shape `[None]`.
+
+    Args:
+        proto: Either a `string` path to a SentencePiece proto file, or a
+            `bytes` object with a serialized SentencePiece proto. See the
+            [SentencePiece repository](https://github.com/google/sentencepiece)
+            for more details on the format.
+
+    Examples:
+    ```python
+    # Unbatched input.
+    tokenizer = keras_hub.models.Phi3Tokenizer.from_preset(
+        "phi3_mini_4k_instruct_en",
+    )
+    tokenizer("The quick brown fox jumped.")
+
+    # Batched input.
+    tokenizer(["The quick brown fox jumped.", "The fox slept."])
+
+    # Detokenization.
+    tokenizer.detokenize(tokenizer("The quick brown fox jumped."))
+    ```
+    """
+
+    def __init__(self, proto, **kwargs):
+        self.start_token = "<s>"
+        self.end_token = "<|endoftext|>"
+        super().__init__(proto=proto, **kwargs)
+
+    def set_proto(self, proto):
+        super().set_proto(proto)
+        if proto is not None:
+            for token in [self.start_token, self.end_token]:
+                if token not in self.get_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.end_token_id = self.token_to_id(self.end_token)
+            # TODO: `pad_token` is `<|endoftext|>`, but setting it to `<unk>`
+            # for now, because of the way sampler works. sampler will think that
+            # `pad_token` is `end_token` and stop generation immediatly.
+            self.pad_token_id = 0
+        else:
+            self.start_token_id = None
+            self.end_token_id = None
+            self.pad_token_id = None
+
+    @classproperty
+    def presets(cls):
+        return copy.deepcopy(backbone_presets)

keras_hub/src/models/preprocessor.py

@@ -0,0 +1,207 @@
+# 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.
+
+import keras
+
+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 PREPROCESSOR_CONFIG_FILE
+from keras_hub.src.utils.preset_utils import TOKENIZER_CONFIG_FILE
+from keras_hub.src.utils.preset_utils import check_config_class
+from keras_hub.src.utils.preset_utils import check_file_exists
+from keras_hub.src.utils.preset_utils import check_format
+from keras_hub.src.utils.preset_utils import list_presets
+from keras_hub.src.utils.preset_utils import list_subclasses
+from keras_hub.src.utils.preset_utils import load_serialized_object
+from keras_hub.src.utils.preset_utils import save_serialized_object
+from keras_hub.src.utils.python_utils import classproperty
+
+
+@keras_hub_export("keras_hub.models.Preprocessor")
+class Preprocessor(PreprocessingLayer):
+    """Base class for preprocessing layers.
+
+    A `Preprocessor` layer wraps a `keras_hub.tokenizer.Tokenizer` to provide a
+    complete preprocessing setup for a given task. For example a masked language
+    modeling preprocessor will take in raw input strings, and output
+    `(x, y, sample_weight)` tuples. Where `x` contains token id sequences with
+    some
+
+    This class can be subclassed similar to any `keras.layers.Layer`, by
+    defining `build()`, `call()` and `get_config()` methods. All subclasses
+    should set the `tokenizer` property on construction.
+    """
+
+    tokenizer_cls = None
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._tokenizer = None
+
+    def __setattr__(self, name, value):
+        # Work around torch setattr for properties.
+        if name in ["tokenizer"]:
+            return object.__setattr__(self, name, value)
+        return super().__setattr__(name, value)
+
+    @property
+    def tokenizer(self):
+        """The tokenizer used to tokenize strings."""
+        return self._tokenizer
+
+    @tokenizer.setter
+    def tokenizer(self, value):
+        self._tokenizer = value
+
+    def get_config(self):
+        config = super().get_config()
+        config["tokenizer"] = keras.layers.serialize(self.tokenizer)
+        return config
+
+    @classmethod
+    def from_config(cls, config):
+        if "tokenizer" in config and isinstance(config["tokenizer"], dict):
+            config["tokenizer"] = keras.layers.deserialize(config["tokenizer"])
+        return cls(**config)
+
+    @classproperty
+    def presets(cls):
+        presets = list_presets(cls)
+        # We can also load backbone presets.
+        if cls.tokenizer_cls is not None:
+            presets.update(cls.tokenizer_cls.presets)
+        for subclass in list_subclasses(cls):
+            presets.update(subclass.presets)
+        return presets
+
+    @classmethod
+    def from_preset(
+        cls,
+        preset,
+        **kwargs,
+    ):
+        """Instantiate a `keras_hub.models.Preprocessor` 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 a
+        one of:
+
+        1. a built in preset identifier like `'bert_base_en'`
+        2. a Kaggle Models handle like `'kaggle://user/bert/keras/bert_base_en'`
+        3. a Hugging Face handle like `'hf://user/bert_base_en'`
+        4. a path to a local preset directory like `'./bert_base_en'`
+
+        For any `Preprocessor` subclass, you can run `cls.presets.keys()` to
+        list all built-in presets available on the class.
+
+        As there are usually multiple preprocessing classes for a given model,
+        this method should be called on a specific subclass like
+        `keras_hub.models.BertPreprocessor.from_preset()`.
+
+        Args:
+            preset: string. A built in preset identifier, a Kaggle Models
+                handle, a Hugging Face handle, or a path to a local directory.
+
+        Examples:
+        ```python
+        # Load a preprocessor for Gemma generation.
+        preprocessor = keras_hub.models.GemmaCausalLMPreprocessor.from_preset(
+            "gemma_2b_en",
+        )
+
+        # Load a preprocessor for Bert classification.
+        preprocessor = keras_hub.models.BertPreprocessor.from_preset(
+            "bert_base_en",
+        )
+        ```
+        """
+        format = check_format(preset)
+
+        if format == "transformers":
+            if cls.tokenizer_cls is None:
+                raise ValueError("Tokenizer class is None")
+            tokenizer = cls.tokenizer_cls.from_preset(preset)
+            return cls(tokenizer=tokenizer, **kwargs)
+
+        if cls == Preprocessor:
+            raise ValueError(
+                "Do not call `Preprocessor.from_preset()` directly. Instead call a "
+                "choose a particular task class, e.g. "
+                "`keras_hub.models.BertPreprocessor.from_preset()`."
+            )
+        # Check if we should load a `preprocessor.json` directly.
+        load_preprocessor_config = False
+        if check_file_exists(preset, PREPROCESSOR_CONFIG_FILE):
+            preprocessor_preset_cls = check_config_class(
+                preset, PREPROCESSOR_CONFIG_FILE
+            )
+            if issubclass(preprocessor_preset_cls, cls):
+                load_preprocessor_config = True
+        if load_preprocessor_config:
+            # Preprocessor case.
+            preprocessor = load_serialized_object(
+                preset,
+                PREPROCESSOR_CONFIG_FILE,
+            )
+            preprocessor.tokenizer.load_preset_assets(preset)
+            return preprocessor
+
+        # Tokenizer case.
+        # If `preprocessor.json` doesn't exist or preprocessor preset class is
+        # different from the calling class, create the preprocessor based on
+        # `tokenizer.json`.
+        tokenizer_preset_cls = check_config_class(
+            preset, config_file=TOKENIZER_CONFIG_FILE
+        )
+        if tokenizer_preset_cls is not cls.tokenizer_cls:
+            subclasses = list_subclasses(cls)
+            subclasses = tuple(
+                filter(
+                    lambda x: x.tokenizer_cls == tokenizer_preset_cls,
+                    subclasses,
+                )
+            )
+            if len(subclasses) == 0:
+                raise ValueError(
+                    f"No registered subclass of `{cls.__name__}` can load "
+                    f"a `{tokenizer_preset_cls.__name__}`."
+                )
+            if len(subclasses) > 1:
+                names = ", ".join(f"`{x.__name__}`" for x in subclasses)
+                raise ValueError(
+                    f"Ambiguous call to `{cls.__name__}.from_preset()`. "
+                    f"Found multiple possible subclasses {names}. "
+                    "Please call `from_preset` on a subclass directly."
+                )
+
+        tokenizer = load_serialized_object(preset, TOKENIZER_CONFIG_FILE)
+        tokenizer.load_preset_assets(preset)
+        preprocessor = cls(tokenizer=tokenizer, **kwargs)
+
+        return preprocessor
+
+    def save_to_preset(self, preset_dir):
+        """Save preprocessor to a preset directory.
+
+        Args:
+            preset_dir: The path to the local model preset directory.
+        """
+        save_serialized_object(
+            self,
+            preset_dir,
+            config_file=PREPROCESSOR_CONFIG_FILE,
+        )
+        self.tokenizer.save_to_preset(preset_dir)

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