keras-hub 0.20.0.dev1__py3-none-any.whl → 0.21.0.dev1__py3-none-any.whl

keras_hub/src/utils/transformers/convert_mixtral.py

@@ -0,0 +1,139 @@
+import numpy as np
+
+from keras_hub.src.models.mixtral.mixtral_backbone import MixtralBackbone
+from keras_hub.src.utils.preset_utils import get_file
+
+backbone_cls = MixtralBackbone
+
+
+def convert_backbone_config(transformers_config):
+    return {
+        "vocabulary_size": transformers_config["vocab_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "num_query_heads": transformers_config["num_attention_heads"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "intermediate_dim": transformers_config["intermediate_size"],
+        "num_key_value_heads": transformers_config["num_key_value_heads"],
+        "num_experts": transformers_config["num_local_experts"],
+        "top_k": transformers_config["num_experts_per_tok"],
+        "rope_max_wavelength": transformers_config["rope_theta"],
+        "layer_norm_epsilon": transformers_config["rms_norm_eps"],
+        "sliding_window": transformers_config["sliding_window"],
+        "output_router_logits": transformers_config["output_router_logits"],
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    # Embeddings
+    loader.port_weight(
+        keras_variable=backbone.get_layer("token_embedding").embeddings,
+        hf_weight_key="model.embed_tokens.weight",
+    )
+    loader.port_weight(
+        keras_variable=backbone.get_layer("token_embedding").reverse_embeddings,
+        hf_weight_key="lm_head.weight",
+        hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+    )
+
+    def transpose_and_reshape(x, shape):
+        return np.reshape(np.transpose(x), shape)
+
+    for i in range(backbone.num_layers):
+        decoder_layer = backbone.get_layer(f"transformer_layer_{i}")
+
+        # Input layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.input_layernorm.weight",
+        )
+
+        # Attention layers
+        ## Query
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.query_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.q_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Key
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.key_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.k_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Value
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.value_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.v_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Output
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.output_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.o_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+
+        # MoE layers
+        # Router gate
+        loader.port_weight(
+            keras_variable=decoder_layer._sparse_moe_block._sparse_feedforward_gate_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.block_sparse_moe.gate.weight",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+
+        # Batched experts: w1 (gate), w3 (intermediate), and w2 (output) weights
+        gate_weights_list = []
+        intermediate_weights_list = []
+        output_weights_list = []
+        for expert_idx in range(backbone.num_experts):
+            # Load w1 (gate dense) for each expert
+            w1 = loader.get_tensor(
+                f"model.layers.{i}.block_sparse_moe.experts.{expert_idx}.w1.weight"
+            )
+            w1_transposed = np.transpose(w1, axes=(1, 0))
+            gate_weights_list.append(w1_transposed)
+
+            w3 = loader.get_tensor(
+                f"model.layers.{i}.block_sparse_moe.experts.{expert_idx}.w3.weight"
+            )
+            w3_transposed = np.transpose(w3, axes=(1, 0))
+            intermediate_weights_list.append(w3_transposed)
+
+            w2 = loader.get_tensor(
+                f"model.layers.{i}.block_sparse_moe.experts.{expert_idx}.w2.weight"
+            )
+            w2_transposed = np.transpose(w2, axes=(1, 0))
+            output_weights_list.append(w2_transposed)
+
+        gate_batched = np.stack(gate_weights_list, axis=0)
+        intermediate_batched = np.stack(intermediate_weights_list, axis=0)
+        output_batched = np.stack(output_weights_list, axis=0)
+
+        # Assign batched weights to expert_bank
+        decoder_layer._sparse_moe_block.expert_bank._expert_feedforward_gate_dense.assign(
+            gate_batched
+        )
+        decoder_layer._sparse_moe_block.expert_bank._expert_feedforward_intermediate_dense.assign(
+            intermediate_batched
+        )
+        decoder_layer._sparse_moe_block.expert_bank._expert_feedforward_output_dense.assign(
+            output_batched
+        )
+
+        # Feedforward layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer._feedforward_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.post_attention_layernorm.weight",
+        )
+
+    # Final normalization layer
+    loader.port_weight(
+        keras_variable=backbone.get_layer("sequence_output_layernorm").scale,
+        hf_weight_key="model.norm.weight",
+    )
+
+    return backbone
+
+
+def convert_tokenizer(cls, preset, **kwargs):
+    return cls(get_file(preset, "tokenizer.model"), **kwargs)

keras_hub/src/utils/transformers/convert_qwen.py

@@ -18,6 +18,7 @@ def convert_backbone_config(transformers_config):
         "rope_max_wavelength": transformers_config["rope_theta"],
         "use_sliding_window": transformers_config["use_sliding_window"],
         "sliding_window_size": transformers_config["sliding_window"],
+        "tie_word_embeddings": transformers_config["tie_word_embeddings"],
     }
 
 

keras_hub/src/utils/transformers/convert_qwen_moe.py

@@ -0,0 +1,253 @@
+import numpy as np
+
+from keras_hub.src.models.qwen_moe.qwen_moe_backbone import QwenMoeBackbone
+from keras_hub.src.utils.preset_utils import load_json
+
+backbone_cls = QwenMoeBackbone
+
+
+def convert_backbone_config(transformers_config):
+    return {
+        "vocabulary_size": transformers_config["vocab_size"],
+        "hidden_dim": transformers_config["hidden_size"],
+        "num_layers": transformers_config["num_hidden_layers"],
+        "num_query_heads": transformers_config["num_attention_heads"],
+        "num_key_value_heads": transformers_config["num_key_value_heads"],
+        "intermediate_dim": transformers_config["intermediate_size"],
+        "moe_intermediate_dim": transformers_config["moe_intermediate_size"],
+        "shared_expert_intermediate_dim": transformers_config[
+            "shared_expert_intermediate_size"
+        ],
+        "num_experts": transformers_config["num_experts"],
+        "top_k": transformers_config["num_experts_per_tok"],
+        "norm_top_k_prob": transformers_config["norm_topk_prob"],
+        "decoder_sparse_step": transformers_config["decoder_sparse_step"],
+        "layer_norm_epsilon": transformers_config["rms_norm_eps"],
+        "rope_max_wavelength": transformers_config["rope_theta"],
+        "use_sliding_window": transformers_config["use_sliding_window"],
+        "sliding_window_size": transformers_config["sliding_window"],
+        "output_router_logits": transformers_config["output_router_logits"],
+        "router_aux_loss_coefficient": transformers_config[
+            "router_aux_loss_coef"
+        ],
+    }
+
+
+def convert_weights(backbone, loader, transformers_config):
+    loader.port_weight(
+        keras_variable=backbone.get_layer("token_embedding").embeddings,
+        hf_weight_key="model.embed_tokens.weight",
+    )
+    if not backbone.tie_word_embeddings:
+        loader.port_weight(
+            keras_variable=backbone.get_layer(
+                "token_embedding"
+            ).reverse_embeddings,
+            hf_weight_key="lm_head.weight",
+            # rearrange_pattern="b a -> a b",
+            hook_fn=lambda hf_tensor, _: np.transpose(hf_tensor, axes=(1, 0)),
+        )
+
+    def transpose_and_reshape(x, shape):
+        return np.reshape(np.transpose(x), shape)
+
+    for i in range(backbone.num_layers):
+        decoder_layer = backbone.get_layer(f"transformer_layer_{i}")
+
+        # Input layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.input_layernorm.weight",
+        )
+
+        # Attention layers
+
+        ## Query
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.query_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.q_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.query_dense.bias,
+            hf_weight_key=f"model.layers.{i}.self_attn.q_proj.bias",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Key
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.key_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.k_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.key_dense.bias,
+            hf_weight_key=f"model.layers.{i}.self_attn.k_proj.bias",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Value
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.value_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.v_proj.weight",
+            hook_fn=transpose_and_reshape,
+        )
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer.value_dense.bias,
+            hf_weight_key=f"model.layers.{i}.self_attn.v_proj.bias",
+            hook_fn=transpose_and_reshape,
+        )
+        ## Output
+        loader.port_weight(
+            keras_variable=decoder_layer._self_attention_layer._output_dense.kernel,
+            hf_weight_key=f"model.layers.{i}.self_attn.o_proj.weight",
+            # rearrange_patterns="c (a b) -> a b c",
+            # rearrange_dims={"a": backbone.num_query_heads},
+            hook_fn=transpose_and_reshape,
+        )
+
+        # MLP layers
+        if (
+            (i not in backbone.mlp_only_layers)
+            and backbone.num_experts > 0
+            and ((i + 1) % backbone.decoder_sparse_step == 0)
+        ):
+            # MoE layers
+            loader.port_weight(
+                keras_variable=decoder_layer.mlp._sparse_feedforward_gate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.gate.weight",
+                # rearrange_patterns="b a -> a b",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+            # Batched experts: gate_up_proj and down_proj
+            gate_up_proj_list = []
+            down_proj_list = []
+            for expert_idx in range(backbone.num_experts):
+                # Load gate_proj and up_proj for each expert
+                gate_proj = loader.get_tensor(
+                    f"model.layers.{i}.mlp.experts.{expert_idx}.gate_proj.weight"
+                )
+                up_proj = loader.get_tensor(
+                    f"model.layers.{i}.mlp.experts.{expert_idx}.up_proj.weight"
+                )
+                # Transpose to (hidden_dim, intermediate_dim)
+                gate_proj = np.transpose(gate_proj, axes=(1, 0))
+                up_proj = np.transpose(up_proj, axes=(1, 0))
+                # Concatenate gate_proj and up_proj along the last dimension
+                gate_up_proj = np.concatenate([gate_proj, up_proj], axis=-1)
+                gate_up_proj_list.append(gate_up_proj)
+
+                # Load down_proj for each expert
+                down_proj = loader.get_tensor(
+                    f"model.layers.{i}.mlp.experts.{expert_idx}.down_proj.weight"
+                )
+                down_proj = np.transpose(
+                    down_proj, axes=(1, 0)
+                )  # (intermediate_dim, hidden_dim)
+                down_proj_list.append(down_proj)
+
+            # Stack the lists to create batched weights
+            gate_up_proj_batched = np.stack(
+                gate_up_proj_list, axis=0
+            )  # (num_experts, hidden_dim, 2 * intermediate_dim)
+            down_proj_batched = np.stack(
+                down_proj_list, axis=0
+            )  # (num_experts, intermediate_dim, hidden_dim)
+
+            # Assign batched weights to expert_bank
+            decoder_layer.mlp.expert_bank._expert_feedforward_gate_dense.assign(
+                gate_up_proj_batched
+            )
+            decoder_layer.mlp.expert_bank._expert_feedforward_output_dense.assign(
+                down_proj_batched
+            )
+
+            loader.port_weight(
+                keras_variable=decoder_layer.mlp.shared_expert_dense._feedforward_intermediate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.shared_expert.up_proj.weight",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+            loader.port_weight(
+                keras_variable=decoder_layer.mlp.shared_expert_dense._feedforward_output_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.shared_expert.down_proj.weight",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+            loader.port_weight(
+                keras_variable=decoder_layer.mlp.shared_expert_dense._feedforward_gate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.shared_expert.gate_proj.weight",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+
+            loader.port_weight(
+                keras_variable=decoder_layer.mlp.shared_expert_gate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.shared_expert_gate.weight",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+        else:
+            loader.port_weight(
+                keras_variable=decoder_layer._feedforward_intermediate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.up_proj.weight",
+                # rearrange_patterns="b a -> a b",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+            loader.port_weight(
+                keras_variable=decoder_layer._feedforward_output_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.down_proj.weight",
+                # rearrange_patterns="b a -> a b",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+            loader.port_weight(
+                keras_variable=decoder_layer._feedforward_gate_dense.kernel,
+                hf_weight_key=f"model.layers.{i}.mlp.gate_proj.weight",
+                # rearrange_patterns="b a -> a b",
+                hook_fn=lambda hf_tensor, _: np.transpose(
+                    hf_tensor, axes=(1, 0)
+                ),
+            )
+
+        # Feedforward layernorm
+        loader.port_weight(
+            keras_variable=decoder_layer._feedforward_layernorm.scale,
+            hf_weight_key=f"model.layers.{i}.post_attention_layernorm.weight",
+        )
+
+    # Final normalization layer
+    loader.port_weight(
+        keras_variable=backbone.get_layer("sequence_output_layernorm").scale,
+        hf_weight_key="model.norm.weight",
+    )
+
+    return backbone
+
+
+def convert_tokenizer(cls, preset, **kwargs):
+    tokenizer_config = load_json(preset, "tokenizer.json")
+    vocab = tokenizer_config["model"]["vocab"]
+    merges = tokenizer_config["model"]["merges"]
+
+    # Load all special tokens with the exception of "reserved" ones.
+    special_tokens = set()
+    for token in tokenizer_config["added_tokens"]:
+        if not token["content"].startswith("<|reserved_special_token_"):
+            vocab[token["content"]] = token["id"]
+            special_tokens.add(token["content"])
+
+    kwargs.update(
+        {
+            "unsplittable_tokens": list(special_tokens),
+        }
+    )
+
+    return cls(vocabulary=vocab, merges=merges, **kwargs)

keras_hub/src/utils/transformers/preset_loader.py

@@ -11,8 +11,10 @@ from keras_hub.src.utils.transformers import convert_gemma
 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_mixtral
 from keras_hub.src.utils.transformers import convert_pali_gemma
 from keras_hub.src.utils.transformers import convert_qwen
+from keras_hub.src.utils.transformers import convert_qwen_moe
 from keras_hub.src.utils.transformers import convert_vit
 from keras_hub.src.utils.transformers.safetensor_utils import SafetensorLoader
 
@@ -44,6 +46,10 @@ class TransformersPresetLoader(PresetLoader):
             self.converter = convert_vit
         elif model_type == "qwen2":
             self.converter = convert_qwen
+        elif model_type == "mixtral":
+            self.converter = convert_mixtral
+        elif model_type == "qwen2_moe":
+            self.converter = convert_qwen_moe
         else:
             raise ValueError(
                 "KerasHub has no converter for huggingface/transformers models "

keras_hub/src/{version_utils.py → version.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.20.0.dev1"
+__version__ = "0.21.0.dev1"
 
 
 @keras_hub_export("keras_hub.version")

keras_hub/tokenizers/__init__.py

@@ -0,0 +1,117 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+from keras_hub.src.models.albert.albert_tokenizer import (
+    AlbertTokenizer as AlbertTokenizer,
+)
+from keras_hub.src.models.bart.bart_tokenizer import (
+    BartTokenizer as BartTokenizer,
+)
+from keras_hub.src.models.bert.bert_tokenizer import (
+    BertTokenizer as BertTokenizer,
+)
+from keras_hub.src.models.bloom.bloom_tokenizer import (
+    BloomTokenizer as BloomTokenizer,
+)
+from keras_hub.src.models.clip.clip_tokenizer import (
+    CLIPTokenizer as CLIPTokenizer,
+)
+from keras_hub.src.models.deberta_v3.deberta_v3_tokenizer import (
+    DebertaV3Tokenizer as DebertaV3Tokenizer,
+)
+from keras_hub.src.models.distil_bert.distil_bert_tokenizer import (
+    DistilBertTokenizer as DistilBertTokenizer,
+)
+from keras_hub.src.models.electra.electra_tokenizer import (
+    ElectraTokenizer as ElectraTokenizer,
+)
+from keras_hub.src.models.f_net.f_net_tokenizer import (
+    FNetTokenizer as FNetTokenizer,
+)
+from keras_hub.src.models.falcon.falcon_tokenizer import (
+    FalconTokenizer as FalconTokenizer,
+)
+from keras_hub.src.models.gemma.gemma_tokenizer import (
+    GemmaTokenizer as GemmaTokenizer,
+)
+from keras_hub.src.models.gemma3.gemma3_tokenizer import (
+    Gemma3Tokenizer as Gemma3Tokenizer,
+)
+from keras_hub.src.models.gpt2.gpt2_tokenizer import (
+    GPT2Tokenizer as GPT2Tokenizer,
+)
+from keras_hub.src.models.gpt_neo_x.gpt_neo_x_tokenizer import (
+    GPTNeoXTokenizer as GPTNeoXTokenizer,
+)
+from keras_hub.src.models.llama.llama_tokenizer import (
+    LlamaTokenizer as LlamaTokenizer,
+)
+from keras_hub.src.models.llama3.llama3_tokenizer import (
+    Llama3Tokenizer as Llama3Tokenizer,
+)
+from keras_hub.src.models.mistral.mistral_tokenizer import (
+    MistralTokenizer as MistralTokenizer,
+)
+from keras_hub.src.models.mixtral.mixtral_tokenizer import (
+    MixtralTokenizer as MixtralTokenizer,
+)
+from keras_hub.src.models.moonshine.moonshine_tokenizer import (
+    MoonshineTokenizer as MoonshineTokenizer,
+)
+from keras_hub.src.models.opt.opt_tokenizer import OPTTokenizer as OPTTokenizer
+from keras_hub.src.models.pali_gemma.pali_gemma_tokenizer import (
+    PaliGemmaTokenizer as PaliGemmaTokenizer,
+)
+from keras_hub.src.models.phi3.phi3_tokenizer import (
+    Phi3Tokenizer as Phi3Tokenizer,
+)
+from keras_hub.src.models.qwen.qwen_tokenizer import (
+    QwenTokenizer as Qwen2Tokenizer,
+)
+from keras_hub.src.models.qwen.qwen_tokenizer import (
+    QwenTokenizer as QwenTokenizer,
+)
+from keras_hub.src.models.qwen_moe.qwen_moe_tokenizer import (
+    QwenMoeTokenizer as QwenMoeTokenizer,
+)
+from keras_hub.src.models.roberta.roberta_tokenizer import (
+    RobertaTokenizer as RobertaTokenizer,
+)
+from keras_hub.src.models.roformer_v2.roformer_v2_tokenizer import (
+    RoformerV2Tokenizer as RoformerV2Tokenizer,
+)
+from keras_hub.src.models.siglip.siglip_tokenizer import (
+    SigLIPTokenizer as SigLIPTokenizer,
+)
+from keras_hub.src.models.t5.t5_tokenizer import T5Tokenizer as T5Tokenizer
+from keras_hub.src.models.whisper.whisper_tokenizer import (
+    WhisperTokenizer as WhisperTokenizer,
+)
+from keras_hub.src.models.xlm_roberta.xlm_roberta_tokenizer import (
+    XLMRobertaTokenizer as XLMRobertaTokenizer,
+)
+from keras_hub.src.tokenizers.byte_pair_tokenizer import (
+    BytePairTokenizer as BytePairTokenizer,
+)
+from keras_hub.src.tokenizers.byte_tokenizer import (
+    ByteTokenizer as ByteTokenizer,
+)
+from keras_hub.src.tokenizers.sentence_piece_tokenizer import (
+    SentencePieceTokenizer as SentencePieceTokenizer,
+)
+from keras_hub.src.tokenizers.sentence_piece_tokenizer_trainer import (
+    compute_sentence_piece_proto as compute_sentence_piece_proto,
+)
+from keras_hub.src.tokenizers.tokenizer import Tokenizer as Tokenizer
+from keras_hub.src.tokenizers.unicode_codepoint_tokenizer import (
+    UnicodeCodepointTokenizer as UnicodeCodepointTokenizer,
+)
+from keras_hub.src.tokenizers.word_piece_tokenizer import (
+    WordPieceTokenizer as WordPieceTokenizer,
+)
+from keras_hub.src.tokenizers.word_piece_tokenizer_trainer import (
+    compute_word_piece_vocabulary as compute_word_piece_vocabulary,
+)

keras_hub/utils/__init__.py

@@ -0,0 +1,21 @@
+"""DO NOT EDIT.
+
+This file was autogenerated. Do not edit it by hand,
+since your modifications would be overwritten.
+"""
+
+from keras_hub.src.utils.coco.coco_utils import (
+    coco_id_to_name as coco_id_to_name,
+)
+from keras_hub.src.utils.coco.coco_utils import (
+    coco_name_to_id as coco_name_to_id,
+)
+from keras_hub.src.utils.imagenet.imagenet_utils import (
+    decode_imagenet_predictions as decode_imagenet_predictions,
+)
+from keras_hub.src.utils.imagenet.imagenet_utils import (
+    imagenet_id_to_name as imagenet_id_to_name,
+)
+from keras_hub.src.utils.imagenet.imagenet_utils import (
+    imagenet_name_to_id as imagenet_name_to_id,
+)

{keras_hub-0.20.0.dev1.dist-info → keras_hub-0.21.0.dev1.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: keras-hub
-Version: 0.20.0.dev1
-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
+Version: 0.21.0.dev1
+Summary: Pretrained models for Keras.
+Author-email: Keras team <keras-users@googlegroups.com>
+License-Expression: Apache-2.0
+Project-URL: Home, https://keras.io/keras_hub/
+Project-URL: Repository, https://github.com/keras-team/keras/keras_hub
 Classifier: Development Status :: 3 - Alpha
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
@@ -28,20 +28,6 @@ Requires-Dist: regex
 Requires-Dist: rich
 Requires-Dist: kagglehub
 Requires-Dist: tensorflow-text; platform_system != "Windows"
-Provides-Extra: extras
-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)