keras-hub-nightly 0.15.0.dev20240823171555__py3-none-any.whl → 0.16.0.dev2024092017__py3-none-any.whl

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_tokenizer.py

@@ -11,17 +11,19 @@
 # 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.models.phi3.phi3_backbone import Phi3Backbone
 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")
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.Phi3Tokenizer",
+        "keras_hub.models.Phi3Tokenizer",
+    ]
+)
 class Phi3Tokenizer(SentencePieceTokenizer):
     """Phi3 tokenizer layer based on SentencePiece.
 
@@ -31,10 +33,6 @@ class Phi3Tokenizer(SentencePieceTokenizer):
     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.
 
@@ -63,32 +61,10 @@ class Phi3Tokenizer(SentencePieceTokenizer):
     ```
     """
 
+    backbone_cls = Phi3Backbone
+
     def __init__(self, proto, **kwargs):
-        self.start_token = "<s>"
-        self.end_token = "<|endoftext|>"
+        self._add_special_token("<s>", "start_token")
+        self._add_special_token("<|endoftext|>", "end_token")
+        self.pad_token_id = 0
         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

@@ -19,13 +19,9 @@ 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 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.python_utils import classproperty
 
@@ -45,15 +41,20 @@ class Preprocessor(PreprocessingLayer):
     should set the `tokenizer` property on construction.
     """
 
+    backbone_cls = None
     tokenizer_cls = None
+    audio_converter_cls = None
+    image_converter_cls = None
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self._tokenizer = None
+        self._image_converter = None
+        self._audio_converter = None
 
     def __setattr__(self, name, value):
         # Work around torch setattr for properties.
-        if name in ["tokenizer"]:
+        if name in ["tokenizer", "audio_converter", "image_converter"]:
             return object.__setattr__(self, name, value)
         return super().__setattr__(name, value)
 
@@ -66,26 +67,60 @@ class Preprocessor(PreprocessingLayer):
     def tokenizer(self, value):
         self._tokenizer = value
 
+    @property
+    def audio_converter(self):
+        """The audio converter used to preprocess audio data."""
+        return self._audio_converter
+
+    @audio_converter.setter
+    def audio_converter(self, value):
+        self._audio_converter = value
+
+    @property
+    def image_converter(self):
+        """The image converter used to preprocess image data."""
+        return self._image_converter
+
+    @image_converter.setter
+    def image_converter(self, value):
+        self._image_converter = value
+
     def get_config(self):
         config = super().get_config()
-        config["tokenizer"] = keras.layers.serialize(self.tokenizer)
+        if self.tokenizer:
+            config["tokenizer"] = keras.layers.serialize(self.tokenizer)
+        if self.audio_converter:
+            config["audio_converter"] = keras.layers.serialize(
+                self.audio_converter
+            )
+        if self.image_converter:
+            config["image_converter"] = keras.layers.serialize(
+                self.image_converter
+            )
         return config
 
     @classmethod
     def from_config(cls, config):
         if "tokenizer" in config and isinstance(config["tokenizer"], dict):
             config["tokenizer"] = keras.layers.deserialize(config["tokenizer"])
+        if "audio_converter" in config and isinstance(
+            config["audio_converter"], dict
+        ):
+            config["audio_converter"] = keras.layers.deserialize(
+                config["audio_converter"]
+            )
+        if "image_converter" in config and isinstance(
+            config["image_converter"], dict
+        ):
+            config["image_converter"] = keras.layers.deserialize(
+                config["image_converter"]
+            )
         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
+        """List built-in presets for a `Preprocessor` subclass."""
+        return builtin_presets(cls)
 
     @classmethod
     def from_preset(
@@ -96,10 +131,10 @@ class Preprocessor(PreprocessingLayer):
         """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
+        to save and load a pre-trained model. The `preset` can be passed as
         one of:
 
-        1. a built in preset identifier like `'bert_base_en'`
+        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'`
@@ -109,10 +144,10 @@ class Preprocessor(PreprocessingLayer):
 
         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()`.
+        `keras_hub.models.BertTextClassifierPreprocessor.from_preset()`.
 
         Args:
-            preset: string. A built in preset identifier, a Kaggle Models
+            preset: string. A built-in preset identifier, a Kaggle Models
                 handle, a Hugging Face handle, or a path to a local directory.
 
         Examples:
@@ -123,75 +158,24 @@ class Preprocessor(PreprocessingLayer):
         )
 
         # Load a preprocessor for Bert classification.
-        preprocessor = keras_hub.models.BertPreprocessor.from_preset(
+        preprocessor = keras_hub.models.BertTextClassifierPreprocessor.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
+                "Do not call `Preprocessor.from_preset()` directly. Instead "
+                "choose a particular task preprocessing class, e.g. "
+                "`keras_hub.models.TextClassifierPreprocessor.from_preset()`."
             )
-            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
+
+        loader = get_preset_loader(preset)
+        backbone_cls = loader.check_backbone_class()
+        # Detect the correct subclass if we need to.
+        if cls.backbone_cls != backbone_cls:
+            cls = find_subclass(preset, cls, backbone_cls)
+        return loader.load_preprocessor(cls, **kwargs)
 
     def save_to_preset(self, preset_dir):
         """Save preprocessor to a preset directory.
@@ -204,4 +188,9 @@ class Preprocessor(PreprocessingLayer):
             preset_dir,
             config_file=PREPROCESSOR_CONFIG_FILE,
         )
-        self.tokenizer.save_to_preset(preset_dir)
+        if self.tokenizer:
+            self.tokenizer.save_to_preset(preset_dir)
+        if self.audio_converter:
+            self.audio_converter.save_to_preset(preset_dir)
+        if self.image_converter:
+            self.image_converter.save_to_preset(preset_dir)

keras_hub/src/models/resnet/__init__.py

@@ -11,3 +11,9 @@
 # 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.models.resnet.resnet_backbone import ResNetBackbone
+from keras_hub.src.models.resnet.resnet_presets import backbone_presets
+from keras_hub.src.utils.preset_utils import register_presets
+
+register_presets(backbone_presets, ResNetBackbone)