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

keras_hub/src/utils/preset_utils.py

@@ -569,7 +569,16 @@ def load_serialized_object(config, **kwargs):
 
 def check_config_class(config):
     """Validate a preset is being loaded on the correct class."""
-    return keras.saving.get_registered_object(config["registered_name"])
+    registered_name = config["registered_name"]
+    cls = keras.saving.get_registered_object(registered_name)
+    if cls is None:
+        raise ValueError(
+            f"Attempting to load class {registered_name} with "
+            "`from_preset()`, but there is no class registered with Keras "
+            f"for {registered_name}. Make sure to register any custom "
+            "classes with `register_keras_serializable()`."
+        )
+    return cls
 
 
 def jax_memory_cleanup(layer):
@@ -668,7 +677,7 @@ class PresetLoader:
         """Load an image converter layer from the preset."""
         raise NotImplementedError
 
-    def load_task(self, cls, load_weights, load_task_extras, **kwargs):
+    def load_task(self, cls, load_weights, load_task_weights, **kwargs):
         """Load a task model from the preset.
 
         By default, we create a task from a backbone and preprocessor with
@@ -684,11 +693,10 @@ class PresetLoader:
         if "preprocessor" not in kwargs and cls.preprocessor_cls:
             kwargs["preprocessor"] = self.load_preprocessor(
                 cls.preprocessor_cls,
-                load_task_extras=load_task_extras,
             )
         return cls(**kwargs)
 
-    def load_preprocessor(self, cls, load_task_extras, **kwargs):
+    def load_preprocessor(self, cls, **kwargs):
         """Load a prepocessor layer from the preset.
 
         By default, we create a preprocessor from a tokenizer with default
@@ -733,33 +741,25 @@ class KerasPresetLoader(PresetLoader):
         converter_config = load_json(self.preset, IMAGE_CONVERTER_CONFIG_FILE)
         return load_serialized_object(converter_config, **kwargs)
 
-    def load_task(self, cls, load_weights, load_task_extras, **kwargs):
+    def load_task(self, cls, load_weights, load_task_weights, **kwargs):
         # If there is no `task.json` or it's for the wrong class delegate to the
         # super class loader.
-        if not load_task_extras:
-            return super().load_task(
-                cls, load_weights, load_task_extras, **kwargs
-            )
         if not check_file_exists(self.preset, TASK_CONFIG_FILE):
-            raise ValueError(
-                "Saved preset has no `task.json`, cannot load the task config "
-                "from a file. Call `from_preset()` with "
-                "`load_task_extras=False` to load the task from a backbone "
-                "with library defaults."
+            return super().load_task(
+                cls, load_weights, load_task_weights, **kwargs
             )
         task_config = load_json(self.preset, TASK_CONFIG_FILE)
         if not issubclass(check_config_class(task_config), cls):
-            raise ValueError(
-                f"Saved `task.json`does not match calling cls {cls}. Call "
-                "`from_preset()` with `load_task_extras=False` to load the "
-                "task from a backbone with library defaults."
+            return super().load_task(
+                cls, load_weights, load_task_weights, **kwargs
             )
         # We found a `task.json` with a complete config for our class.
         task = load_serialized_object(task_config, **kwargs)
         if task.preprocessor and task.preprocessor.tokenizer:
             task.preprocessor.tokenizer.load_preset_assets(self.preset)
         if load_weights:
-            if check_file_exists(self.preset, TASK_WEIGHTS_FILE):
+            has_task_weights = check_file_exists(self.preset, TASK_WEIGHTS_FILE)
+            if has_task_weights and load_task_weights:
                 jax_memory_cleanup(task)
                 task_weights = get_file(self.preset, TASK_WEIGHTS_FILE)
                 task.load_task_weights(task_weights)
@@ -769,23 +769,14 @@ class KerasPresetLoader(PresetLoader):
             task.backbone.load_weights(backbone_weights)
         return task
 
-    def load_preprocessor(self, cls, load_task_extras, **kwargs):
-        if not load_task_extras:
-            return super().load_preprocessor(cls, load_task_extras, **kwargs)
+    def load_preprocessor(self, cls, **kwargs):
+        # If there is no `preprocessing.json` or it's for the wrong class,
+        # delegate to the super class loader.
         if not check_file_exists(self.preset, PREPROCESSOR_CONFIG_FILE):
-            raise ValueError(
-                "Saved preset has no `preprocessor.json`, cannot load the task "
-                "preprocessing config from a file. Call `from_preset()` with "
-                "`load_task_extras=False` to load the preprocessor with "
-                "library defaults."
-            )
+            return super().load_preprocessor(cls, **kwargs)
         preprocessor_json = load_json(self.preset, PREPROCESSOR_CONFIG_FILE)
         if not issubclass(check_config_class(preprocessor_json), cls):
-            raise ValueError(
-                f"Saved `preprocessor.json`does not match calling cls {cls}. "
-                "Call `from_preset()` with `load_task_extras=False` to "
-                "load the the preprocessor with library defaults."
-            )
+            return super().load_preprocessor(cls, **kwargs)
         # We found a `preprocessing.json` with a complete config for our class.
         preprocessor = load_serialized_object(preprocessor_json, **kwargs)
         preprocessor.tokenizer.load_preset_assets(self.preset)

keras_hub/src/utils/tensor_utils.py

@@ -30,20 +30,19 @@ except ImportError:
 
 
 NO_CONVERT_COUNTER = threading.local()
-NO_CONVERT_COUNTER.count = 0
 
 
 @contextlib.contextmanager
 def no_convert_scope():
     try:
-        NO_CONVERT_COUNTER.count += 1
+        NO_CONVERT_COUNTER.count = getattr(NO_CONVERT_COUNTER, "count", 0) + 1
         yield
     finally:
-        NO_CONVERT_COUNTER.count -= 1
+        NO_CONVERT_COUNTER.count = getattr(NO_CONVERT_COUNTER, "count", 0) - 1
 
 
 def in_no_convert_scope():
-    return NO_CONVERT_COUNTER.count > 0
+    return getattr(NO_CONVERT_COUNTER, "count", 0) > 0
 
 
 def preprocessing_function(fn):
@@ -53,20 +52,21 @@ def preprocessing_function(fn):
 
     params = inspect.signature(fn).parameters
     accepts_labels = all(k in params for k in ("x", "y", "sample_weight"))
-    with tf.device("cpu"):
-        if not accepts_labels:
+    if not accepts_labels:
 
-            @functools.wraps(fn)
-            def wrapper(self, x, **kwargs):
+        @functools.wraps(fn)
+        def wrapper(self, x, **kwargs):
+            with tf.device("cpu"):
                 x = convert_preprocessing_inputs(x)
                 with no_convert_scope():
                     x = fn(self, x, **kwargs)
                 return convert_preprocessing_outputs(x)
 
-        else:
+    else:
 
-            @functools.wraps(fn)
-            def wrapper(self, x, y=None, sample_weight=None, **kwargs):
+        @functools.wraps(fn)
+        def wrapper(self, x, y=None, sample_weight=None, **kwargs):
+            with tf.device("cpu"):
                 x, y, sample_weight = convert_preprocessing_inputs(
                     (x, y, sample_weight)
                 )
@@ -74,7 +74,7 @@ def preprocessing_function(fn):
                     x = fn(self, x, y=y, sample_weight=sample_weight, **kwargs)
                 return convert_preprocessing_outputs(x)
 
-        return wrapper
+    return wrapper
 
 
 def convert_preprocessing_inputs(x):
@@ -118,7 +118,7 @@ def convert_preprocessing_inputs(x):
         return {k: convert_preprocessing_inputs(x[k]) for k, v in x.items()}
     if isinstance(x, tuple):
         return tuple(convert_preprocessing_inputs(v) for v in x)
-    if isinstance(x, str):
+    if isinstance(x, (str, bytes)):
         return tf.constant(x)
     if isinstance(x, list):
         try:
@@ -131,7 +131,7 @@ def convert_preprocessing_inputs(x):
                 # If ragged conversion failed return to the numpy error.
                 raise e
         # If we have a string input, use tf.tensor.
-        if numpy_x.dtype.type is np.str_:
+        if numpy_x.dtype.type is np.str_ or numpy_x.dtype.type is np.bytes_:
             return tf.convert_to_tensor(x)
         # Numpy will default to int64, int32 works with more ops.
         if numpy_x.dtype == np.int64:

keras_hub/src/utils/timm/convert_resnet.py

@@ -172,4 +172,3 @@ def convert_head(task, loader, timm_config):
         task.output_dense.bias,
         hf_weight_key=prefix + "bias",
     )
-    return task

keras_hub/src/utils/timm/preset_loader.py

@@ -45,16 +45,15 @@ class TimmPresetLoader(PresetLoader):
                 self.converter.convert_weights(backbone, loader, self.config)
         return backbone
 
-    def load_task(self, cls, load_weights, load_task_extras, **kwargs):
-        if not load_task_extras or not issubclass(cls, ImageClassifier):
+    def load_task(self, cls, load_weights, load_task_weights, **kwargs):
+        if not load_task_weights or not issubclass(cls, ImageClassifier):
             return super().load_task(
-                cls, load_weights, load_task_extras, **kwargs
+                cls, load_weights, load_task_weights, **kwargs
             )
         # Support loading the classification head for classifier models.
-        if "num_classes" not in kwargs:
-            kwargs["num_classes"] = self.config["num_classes"]
-        task = super().load_task(cls, load_weights, load_task_extras, **kwargs)
-        if load_weights:
+        kwargs["num_classes"] = self.config["num_classes"]
+        task = super().load_task(cls, load_weights, load_task_weights, **kwargs)
+        if load_task_weights:
             with SafetensorLoader(self.preset, prefix="") as loader:
                 self.converter.convert_head(task, loader, self.config)
         return task

keras_hub/src/version_utils.py

@@ -15,7 +15,7 @@
 from keras_hub.src.api_export import keras_hub_export
 
 # Unique source of truth for the version number.
-__version__ = "0.15.0.dev20240911134614"
+__version__ = "0.16.0.dev2024092017"
 
 
 @keras_hub_export("keras_hub.version")

keras_hub_nightly-0.16.0.dev2024092017.dist-info/METADATA

@@ -0,0 +1,202 @@
+Metadata-Version: 2.1
+Name: keras_hub-nightly
+Version: 0.16.0.dev2024092017
+Summary: Industry-strength Natural Language Processing extensions for Keras.
+Home-page: https://github.com/keras-team/keras-hub
+Author: Keras team
+Author-email: keras-hub@google.com
+License: Apache License 2.0
+Classifier: Development Status :: 3 - Alpha
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: Unix
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: MacOS
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: absl-py
+Requires-Dist: numpy
+Requires-Dist: packaging
+Requires-Dist: regex
+Requires-Dist: rich
+Requires-Dist: kagglehub
+Requires-Dist: tensorflow-text ; platform_system != "Darwin"
+Provides-Extra: extras
+Requires-Dist: rouge-score ; extra == 'extras'
+Requires-Dist: sentencepiece ; extra == 'extras'
+
+# KerasNLP: Multi-framework NLP Models
+[![](https://github.com/keras-team/keras-hub/workflows/Tests/badge.svg?branch=master)](https://github.com/keras-team/keras-hub/actions?query=workflow%3ATests+branch%3Amaster)
+![Python](https://img.shields.io/badge/python-v3.9.0+-success.svg)
+[![contributions welcome](https://img.shields.io/badge/contributions-welcome-brightgreen.svg?style=flat)](https://github.com/keras-team/keras-hub/issues)
+
+> [!IMPORTANT]
+> 📢 KerasNLP is becoming KerasHub! 📢 Read
+> [the announcement](https://github.com/keras-team/keras-hub/issues/1831).
+>
+> We have renamed the repo to KerasHub in preparation for the release, but have not yet
+> released the new package. Follow the announcement for news.
+
+KerasNLP is a natural language processing library that works natively
+with TensorFlow, JAX, or PyTorch. KerasNLP provides a repository of pre-trained
+models and a collection of lower-level building blocks for language modeling.
+Built on Keras 3, models can be trained and serialized in any framework
+and re-used in another without costly migrations.
+
+This library is an extension of the core Keras API; all high-level modules are
+Layers and Models that receive that same level of polish as core Keras.
+If you are familiar with Keras, congratulations! You already understand most of
+KerasNLP.
+
+All models support JAX, TensorFlow, and PyTorch from a single model
+definition and can be fine-tuned on GPUs and TPUs out of the box. Models can
+be trained on individual accelerators with built-in PEFT techniques, or
+fine-tuned at scale with model and data parallel training. See our
+[Getting Started guide](https://keras.io/guides/keras_nlp/getting_started)
+to start learning our API. Browse our models on
+[Kaggle](https://www.kaggle.com/organizations/keras/models).
+We welcome contributions.
+
+## Quick Links
+
+### For everyone
+
+- [Home Page](https://keras.io/keras_nlp)
+- [Developer Guides](https://keras.io/guides/keras_nlp)
+- [API Reference](https://keras.io/api/keras_nlp)
+- [Pre-trained Models](https://www.kaggle.com/organizations/keras/models)
+
+### For contributors
+
+- [Contributing Guide](CONTRIBUTING.md)
+- [Roadmap](ROADMAP.md)
+- [Style Guide](STYLE_GUIDE.md)
+- [API Design Guide](API_DESIGN_GUIDE.md)
+- [Call for Contributions](https://github.com/keras-team/keras-hub/issues?q=is%3Aissue+is%3Aopen+label%3A%22contributions+welcome%22)
+
+## Quickstart
+
+Fine-tune BERT on IMDb movie reviews:
+
+```python
+import os
+os.environ["KERAS_BACKEND"] = "jax"  # Or "tensorflow" or "torch"!
+
+import keras_nlp
+import tensorflow_datasets as tfds
+
+imdb_train, imdb_test = tfds.load(
+    "imdb_reviews",
+    split=["train", "test"],
+    as_supervised=True,
+    batch_size=16,
+)
+# Load a BERT model.
+classifier = keras_nlp.models.Classifier.from_preset(
+    "bert_base_en", 
+    num_classes=2,
+    activation="softmax",
+)
+# Fine-tune on IMDb movie reviews.
+classifier.fit(imdb_train, validation_data=imdb_test)
+# Predict two new examples.
+classifier.predict(["What an amazing movie!", "A total waste of my time."])
+```
+
+Try it out [in a colab](https://colab.research.google.com/gist/mattdangerw/e457e42d5ea827110c8d5cb4eb9d9a07/kerasnlp-quickstart.ipynb).
+For more in depth guides and examples, visit
+[keras.io/keras_nlp](https://keras.io/keras_nlp/).
+
+## Installation
+
+To install the latest KerasNLP release with Keras 3, simply run:
+
+```
+pip install --upgrade keras-nlp
+```
+
+To install the latest nightly changes for both KerasNLP and Keras, you can use
+our nightly package.
+
+```
+pip install --upgrade keras-nlp-nightly
+```
+
+Note that currently, installing KerasNLP will always pull in TensorFlow for use
+of the `tf.data` API for preprocessing. Even when pre-processing with `tf.data`,
+training can still happen on any backend.
+
+Read [Getting started with Keras](https://keras.io/getting_started/) for more
+information on installing Keras 3 and compatibility with different frameworks.
+
+> [!IMPORTANT]
+> We recommend using KerasNLP with TensorFlow 2.16 or later, as TF 2.16 packages
+> Keras 3 by default.
+
+## Configuring your backend
+
+If you have Keras 3 installed in your environment (see installation above),
+you can use KerasNLP with any of JAX, TensorFlow and PyTorch. To do so, set the
+`KERAS_BACKEND` environment variable. For example:
+
+```shell
+export KERAS_BACKEND=jax
+```
+
+Or in Colab, with:
+
+```python
+import os
+os.environ["KERAS_BACKEND"] = "jax"
+
+import keras_nlp
+```
+
+> [!IMPORTANT]
+> Make sure to set the `KERAS_BACKEND` before import any Keras libraries, it
+> will be used to set up Keras when it is first imported.
+
+## Compatibility
+
+We follow [Semantic Versioning](https://semver.org/), and plan to
+provide backwards compatibility guarantees both for code and saved models built
+with our components. While we continue with pre-release `0.y.z` development, we
+may break compatibility at any time and APIs should not be consider stable.
+
+## Disclaimer
+
+KerasNLP provides access to pre-trained models via the `keras_nlp.models` API.
+These pre-trained models are provided on an "as is" basis, without warranties
+or conditions of any kind. The following underlying models are provided by third
+parties, and subject to separate licenses:
+BART, BLOOM, DeBERTa, DistilBERT, GPT-2, Llama, Mistral, OPT, RoBERTa, Whisper,
+and XLM-RoBERTa.
+
+## Citing KerasNLP
+
+If KerasNLP helps your research, we appreciate your citations.
+Here is the BibTeX entry:
+
+```bibtex
+@misc{kerasnlp2022,
+  title={KerasNLP},
+  author={Watson, Matthew, and Qian, Chen, and Bischof, Jonathan and Chollet, 
+  Fran\c{c}ois and others},
+  year={2022},
+  howpublished={\url{https://github.com/keras-team/keras-hub}},
+}
+```
+
+## Acknowledgements
+
+Thank you to all of our wonderful contributors!
+
+<a href="https://github.com/keras-team/keras-hub/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=keras-team/keras-hub" />
+</a>