keras-hub-nightly 0.16.1.dev202410020340__py3-none-any.whl → 0.19.0.dev202501260345__py3-none-any.whl

keras_hub/src/utils/transformers/convert_vit.py

@@ -0,0 +1,150 @@
+import numpy as np
+
+from keras_hub.src.models.vit.vit_backbone import ViTBackbone
+
+backbone_cls = ViTBackbone
+
+
+def convert_backbone_config(transformers_config):
+    image_size = transformers_config["image_size"]
+    return {
+        "image_shape": (image_size, image_size, 3),
+        "patch_size": transformers_config["patch_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "num_heads": transformers_config["num_attention_heads"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "mlp_dim": transformers_config["intermediate_size"],
+        "dropout_rate": transformers_config["hidden_dropout_prob"],
+        "attention_dropout": transformers_config[
+            "attention_probs_dropout_prob"
+        ],
+        "use_mha_bias": transformers_config["qkv_bias"],
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    def port_ln(keras_variable, weight_key):
+        loader.port_weight(keras_variable.gamma, f"{weight_key}.weight")
+        loader.port_weight(keras_variable.beta, f"{weight_key}.bias")
+
+    def port_dense(keras_variable, weight_key):
+        loader.port_weight(
+            keras_variable.kernel,
+            f"{weight_key}.weight",
+            hook_fn=lambda x, _: x.T,
+        )
+        if keras_variable.bias is not None:
+            loader.port_weight(keras_variable.bias, f"{weight_key}.bias")
+
+    def port_mha(keras_variable, weight_key, num_heads, hidden_dim):
+        # query
+        loader.port_weight(
+            keras_variable.query_dense.kernel,
+            f"{weight_key}.attention.query.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.query_dense.bias,
+            f"{weight_key}.attention.query.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # key
+        loader.port_weight(
+            keras_variable.key_dense.kernel,
+            f"{weight_key}.attention.key.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.key_dense.bias,
+            f"{weight_key}.attention.key.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # value
+        loader.port_weight(
+            keras_variable.value_dense.kernel,
+            f"{weight_key}.attention.value.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (hidden_dim, num_heads, hidden_dim // num_heads)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.value_dense.bias,
+            f"{weight_key}.attention.value.bias",
+            hook_fn=lambda x, _: np.reshape(
+                x, (num_heads, hidden_dim // num_heads)
+            ),
+        )
+        # output
+        loader.port_weight(
+            keras_variable.output_dense.kernel,
+            f"{weight_key}.output.dense.weight",
+            hook_fn=lambda x, _: np.reshape(
+                x.T, (num_heads, hidden_dim // num_heads, hidden_dim)
+            ),
+        )
+        loader.port_weight(
+            keras_variable.output_dense.bias, f"{weight_key}.output.dense.bias"
+        )
+
+    loader.port_weight(
+        keras_variable=backbone.layers[1].patch_embedding.kernel,
+        hf_weight_key="vit.embeddings.patch_embeddings.projection.weight",
+        hook_fn=lambda x, _: np.transpose(x, (2, 3, 1, 0)),
+    )
+
+    loader.port_weight(
+        backbone.layers[1].patch_embedding.bias,
+        "vit.embeddings.patch_embeddings.projection.bias",
+    )
+
+    loader.port_weight(
+        backbone.layers[1].class_token,
+        "vit.embeddings.cls_token",
+    )
+
+    loader.port_weight(
+        backbone.layers[1].position_embedding.embeddings,
+        "vit.embeddings.position_embeddings",
+        hook_fn=lambda x, _: x[0],
+    )
+    encoder_layers = backbone.layers[2].encoder_layers
+    for i, encoder_block in enumerate(encoder_layers):
+        prefix = "vit.encoder.layer"
+        num_heads = encoder_block.num_heads
+        hidden_dim = encoder_block.hidden_dim
+
+        port_mha(
+            encoder_block.mha,
+            f"{prefix}.{i}.attention",
+            num_heads,
+            hidden_dim,
+        )
+        port_ln(encoder_block.layer_norm_1, f"{prefix}.{i}.layernorm_before")
+        port_ln(encoder_block.layer_norm_2, f"{prefix}.{i}.layernorm_after")
+
+        port_dense(
+            encoder_block.mlp.dense_1, f"{prefix}.{i}.intermediate.dense"
+        )
+        port_dense(encoder_block.mlp.dense_2, f"{prefix}.{i}.output.dense")
+    port_ln(backbone.layers[2].layer_norm, "vit.layernorm")
+
+
+def convert_head(task, loader, transformers_config):
+    prefix = "classifier."
+    loader.port_weight(
+        task.output_dense.kernel,
+        hf_weight_key=prefix + "weight",
+        hook_fn=lambda x, _: x.T,
+    )
+    loader.port_weight(
+        task.output_dense.bias,
+        hf_weight_key=prefix + "bias",
+    )

keras_hub/src/utils/transformers/preset_loader.py

@@ -1,5 +1,6 @@
 """Convert huggingface models to KerasHub."""
 
+from keras_hub.src.models.image_classifier import ImageClassifier
 from keras_hub.src.utils.preset_utils import PresetLoader
 from keras_hub.src.utils.preset_utils import jax_memory_cleanup
 from keras_hub.src.utils.transformers import convert_albert
@@ -11,6 +12,7 @@ from keras_hub.src.utils.transformers import convert_gpt2
 from keras_hub.src.utils.transformers import convert_llama3
 from keras_hub.src.utils.transformers import convert_mistral
 from keras_hub.src.utils.transformers import convert_pali_gemma
+from keras_hub.src.utils.transformers import convert_vit
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
 
 
@@ -37,6 +39,8 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_mistral
         elif model_type == "paligemma":
             self.converter = convert_pali_gemma
+        elif model_type == "vit":
+            self.converter = convert_vit
         else:
             raise ValueError(
                 "KerasHub has no converter for huggingface/transformers models "
@@ -55,6 +59,25 @@ class TransformersPresetLoader(PresetLoader):
                 self.converter.convert_weights(backbone, loader, self.config)
         return backbone
 
+    def load_task(self, cls, load_weights, load_task_weights, **kwargs):
+        architecture = self.config["architectures"][0]
+        if (
+            not load_task_weights
+            or not issubclass(cls, ImageClassifier)
+            or architecture == "ViTModel"
+        ):
+            return super().load_task(
+                cls, load_weights, load_task_weights, **kwargs
+            )
+        # Support loading the classification head for classifier models.
+        if architecture == "ViTForImageClassification":
+            kwargs["num_classes"] = len(self.config["id2label"])
+        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
+
     def load_tokenizer(self, cls, config_name="tokenizer.json", **kwargs):
         return self.converter.convert_tokenizer(cls, self.preset, **kwargs)
 

keras_hub/src/utils/transformers/safetensor_utils.py

@@ -42,12 +42,13 @@ class SafetensorLoader(contextlib.ExitStack):
         """
         Determine and return a prefixed key for a given hf weight key.
 
-        This method checks if there's a common prefix for the weight keys and caches it
-        for future use.
+        This method checks if there's a common prefix for the weight keys and
+        caches it for future use.
 
         Args:
             hf_weight_key (str): The hf weight key to check for a prefix.
-            dict_like (object): An object to get keys of safetensor file using keys() method.
+            dict_like (object): An object to get keys of safetensor file using
+                keys() method.
 
         Returns:
             str: The full key including the prefix (if any).

keras_hub/src/version_utils.py

@@ -1,7 +1,7 @@
 from keras_hub.src.api_export import keras_hub_export
 
 # Unique source of truth for the version number.
-__version__ = "0.16.1.dev202410020340"
+__version__ = "0.19.0.dev202501260345"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.16.1.dev202410020340.dist-info → keras_hub_nightly-0.19.0.dev202501260345.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: keras-hub-nightly
-Version: 0.16.1.dev202410020340
+Version: 0.19.0.dev202501260345
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team
@@ -20,129 +20,147 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+Requires-Dist: keras>=3.5
 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"
+Requires-Dist: tensorflow-text
 Provides-Extra: extras
-Requires-Dist: rouge-score ; extra == 'extras'
-Requires-Dist: sentencepiece ; extra == 'extras'
-
-# KerasHub: Multi-framework Models
+Requires-Dist: rouge-score; extra == "extras"
+Requires-Dist: sentencepiece; extra == "extras"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# KerasHub: Multi-framework Pretrained 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
+> 📢 KerasNLP is now 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.
-
-KerasHub is a library that supports natural language processing, computer
-vision, audio, and multimodal backbones and task models, working natively with
-TensorFlow, JAX, or PyTorch. KerasHub provides a repository of pre-trained
-models and a collection of lower-level building blocks for these tasks. 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
-KerasHub.
+
+**KerasHub** is a pretrained modeling library that aims to be simple, flexible,
+and fast. The library provides [Keras 3](https://keras.io/keras_3/)
+implementations of popular model architectures, paired with a collection of
+pretrained checkpoints available on [Kaggle Models](https://kaggle.com/models/).
+Models can be used with text, image, and audio data for generation, classification,
+and many other built in tasks.
+
+KerasHub is an extension of the core Keras API; KerasHub components are provided
+as `Layer` and `Model` implementations. If you are  familiar with Keras,
+congratulations! You already understand most of KerasHub.
 
 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.
+[Getting Started guide](https://keras.io/guides/keras_hub/getting_started)
+to start learning our API.
 
 ## 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)
+- [Home page](https://keras.io/keras_hub)
+- [Getting started](https://keras.io/keras_hub/getting_started)
+- [Guides](https://keras.io/keras_hub/guides)
+- [API documentation](https://keras.io/keras_hub/api)
+- [Pre-trained models](https://keras.io/keras_hub/presets/)
 
 ### For contributors
 
+- [Call for Contributions](https://github.com/keras-team/keras-hub/issues/1835)
+- [Roadmap](https://github.com/keras-team/keras-hub/issues/1836)
 - [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 a BERT classifier on IMDb movie reviews:
+Choose a backend:
 
 ```python
 import os
 os.environ["KERAS_BACKEND"] = "jax"  # Or "tensorflow" or "torch"!
+```
 
-import keras_nlp
+Import KerasHub and other libraries:
+
+```python
+import keras
+import keras_hub
+import numpy as np
 import tensorflow_datasets as tfds
+```
+
+Load a resnet model and use it to predict a label for an image:
+
+```python
+classifier = keras_hub.models.ImageClassifier.from_preset(
+    "resnet_50_imagenet",
+    activation="softmax",
+)
+url = "https://upload.wikimedia.org/wikipedia/commons/a/aa/California_quail.jpg"
+path = keras.utils.get_file(origin=url)
+image = keras.utils.load_img(path)
+preds = classifier.predict(np.array([image]))
+print(keras_hub.utils.decode_imagenet_predictions(preds))
+```
+
+Load a Bert model and fine-tune it on IMDb movie reviews:
 
+```python
+classifier = keras_hub.models.BertClassifier.from_preset(
+    "bert_base_en_uncased",
+    activation="softmax",
+    num_classes=2,
+)
 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."])
+preds = classifier.predict(["What an amazing movie!", "A total waste of time."])
+print(preds)
 ```
 
-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
 
-KerasHub is currently in pre-release. Note that pre-release versions may
-introduce breaking changes to the API in future versions. For a stable and
-supported experience, we recommend installing `keras-nlp` version 0.15.1:
+To install the latest KerasHub release with Keras 3, simply run:
 
-```bash
-pip install keras-nlp==0.15.1
+```
+pip install --upgrade keras-hub
 ```
 
-To try out the latest pre-release version of KerasHub, you can use
-our nightly package:
+To install the latest nightly changes for both KerasHub and Keras, you can use
+our nightly package.
 
-```bash
-pip install keras-hub-nightly
+```
+pip install --upgrade keras-hub-nightly
 ```
 
-KerasHub currently requires TensorFlow to be installed 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.
+Currently, installing KerasHub will always pull in TensorFlow for use of the
+`tf.data` API for preprocessing. When pre-processing with `tf.data`, training
+can still happen on any backend.
 
-> [!IMPORTANT]
-> We recommend using KerasHub with TensorFlow 2.16 or later, as TF 2.16 packages
-> Keras 3 by default.
+Visit the [core Keras getting started page](https://keras.io/getting_started/)
+for more information on installing Keras 3, accelerator support, and
+compatibility with different frameworks.
 
 ## Configuring your backend