keras-hub-nightly 0.19.0.dev202503020350__py3-none-any.whl → 0.19.0.dev202503040351__py3-none-any.whl

keras_hub/src/models/siglip/siglip_preprocessor.py

@@ -0,0 +1,162 @@
+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.causal_lm_preprocessor import CausalLMPreprocessor
+from keras_hub.src.models.siglip.siglip_backbone import SigLIPBackbone
+from keras_hub.src.models.siglip.siglip_image_converter import (
+    SigLIPImageConverter,
+)
+from keras_hub.src.models.siglip.siglip_tokenizer import SigLIPTokenizer
+from keras_hub.src.utils.tensor_utils import preprocessing_function
+
+try:
+    import tensorflow as tf
+except ImportError:
+    tf = None
+
+
+@keras_hub_export("keras_hub.models.SigLIPPreprocessor")
+class SigLIPPreprocessor(CausalLMPreprocessor):
+    """SigLIP preprocessor.
+
+    This preprocessing layer is meant for use with
+    `keras_hub.models.SigLIPBackbone`. By default, it will take in batches of
+    strings and images, and return token ids and resized images.
+
+    Args:
+        tokenizer: A `keras_hub.models.SigLIPTokenizer` instance.
+        image_converter: A `keras_hub.models.SigLIPImageConverter` 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. Defaults to `False`.
+        add_end_token: If `True`, the preprocessor will append the tokenizer
+            end token to each input sequence. Defaults to `True`.
+        canonicalize_text: If `True`, the input strings will be canonicalized
+            (converted to lowercase, punctuation removed, and stripped).
+
+    Call arguments:
+        x: A dict with `"prompts"` and `"images"` keys, where `"prompts"` is
+            `tf.Tensor` or list of python strings and `"images"` are the image
+            tensors.
+        y: Label data. Should always be `None` since SigLIP doesn't need the
+            label to calculate the loss.
+        sample_weight: Label weights.
+        sequence_length: Pass to override the configured `sequence_length` of
+            the layer.
+
+    Examples:
+    ```python
+    # Load the preprocessor from a preset.
+    preprocessor = keras_hub.models.SigLIPPreprocessor.from_preset(
+        "siglip_base_patch16_224"
+    )
+
+    # Tokenize the sentence and preprocess the image.
+    preprocessor(
+        {
+            "prompts": "The quick brown fox jumped.",
+            "images": np.ones(shape=(123, 123, 3)),
+        }
+    )
+
+    # Tokenize a batch of sentences and preprocess a batch of images.
+    preprocessor(
+        {
+            "prompts": ["The quick brown fox jumped.", "The fox slept."],
+            "images": np.ones(shape=(2, 123, 123, 3)),
+        }
+    )
+    ```
+    """
+
+    backbone_cls = SigLIPBackbone
+    tokenizer_cls = SigLIPTokenizer
+    image_converter_cls = SigLIPImageConverter
+
+    def __init__(
+        self,
+        tokenizer,
+        image_converter=None,
+        sequence_length=64,
+        add_start_token=False,
+        add_end_token=True,
+        canonicalize_text=True,
+        **kwargs,
+    ):
+        super().__init__(
+            tokenizer=tokenizer,
+            sequence_length=sequence_length,
+            add_start_token=add_start_token,
+            add_end_token=add_end_token,
+            **kwargs,
+        )
+        self.image_converter = image_converter
+        self.canonicalize_text = bool(canonicalize_text)
+
+    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(
+            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 canonicalize_inputs(self, inputs):
+        # Ref: https://github.com/google-research/big_vision/blob/main/big_vision/evaluators/proj/image_text/prompt_engineering.py
+        inputs = tf.convert_to_tensor(inputs)
+        # Do lower case.
+        inputs = tf.strings.lower(inputs)
+        # Remove punctuation.
+        inputs = tf.strings.regex_replace(
+            inputs,
+            (
+                r"!|\"|#|\$|%|&|\\|'|\(|\)|\*|\+|,|-|\.|/|:|;|<|=|>|\?|@|\[|\\|"
+                r"\]|\^|_|`|{|\||}|~"
+            ),
+            "",
+        )
+        inputs = tf.strings.regex_replace(inputs, r"\s+", " ")
+        inputs = tf.strings.strip(inputs)
+        return inputs
+
+    @preprocessing_function
+    def call(
+        self,
+        x,
+        y=None,
+        sample_weight=None,
+        sequence_length=None,
+    ):
+        sequence_length = sequence_length or self.sequence_length
+        images, prompts = x["images"], x["prompts"]
+        if self.canonicalize_text:
+            prompts = self.canonicalize_inputs(prompts)
+        prompts = self.tokenizer(prompts)
+        if self.image_converter:
+            images = self.image_converter(images)
+        token_ids, padding_mask = self.packer(
+            prompts,
+            sequence_length=sequence_length,
+            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,
+            "padding_mask": padding_mask,
+            "images": images,
+        }
+        return keras.utils.pack_x_y_sample_weight(x, y, sample_weight)
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "canonicalize_text": self.canonicalize_text,
+            }
+        )
+        return config

keras_hub/src/models/siglip/siglip_presets.py

@@ -0,0 +1,128 @@
+"""SigLIP model preset configurations."""
+
+# Metadata for loading pretrained model weights.
+backbone_presets = {
+    "siglip_base_patch16_224": {
+        "metadata": {
+            "description": (
+                "200 million parameter, image size 224, pre-trained on WebLi."
+            ),
+            "params": 203156230,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_base_patch16_224/2",
+    },
+    "siglip_base_patch16_256": {
+        "metadata": {
+            "description": (
+                "200 million parameter, image size 256, pre-trained on WebLi."
+            ),
+            "params": 203202370,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_base_patch16_256/1",
+    },
+    "siglip_base_patch16_384": {
+        "metadata": {
+            "description": (
+                "200 million parameter, image size 384, pre-trained on WebLi."
+            ),
+            "params": 203448450,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_base_patch16_384/1",
+    },
+    "siglip_base_patch16_512": {
+        "metadata": {
+            "description": (
+                "200 million parameter, image size 512, pre-trained on WebLi."
+            ),
+            "params": 203792962,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_base_patch16_512/1",
+    },
+    "siglip_large_patch16_256": {
+        "metadata": {
+            "description": (
+                "652 million parameter, image size 256, pre-trained on WebLi."
+            ),
+            "params": 652151106,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_large_patch16_256/1",
+    },
+    "siglip_large_patch16_384": {
+        "metadata": {
+            "description": (
+                "652 million parameter, image size 384, pre-trained on WebLi."
+            ),
+            "params": 652479106,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_large_patch16_384/1",
+    },
+    "siglip_so400m_patch14_224": {
+        "metadata": {
+            "description": (
+                "877 million parameter, image size 224, "
+                "shape-optimized version, pre-trained on WebLi."
+            ),
+            "params": 877360578,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_so400m_patch14_224/2",
+    },
+    "siglip_so400m_patch14_384": {
+        "metadata": {
+            "description": (
+                "877 million parameter, image size 384, "
+                "shape-optimized version, pre-trained on WebLi."
+            ),
+            "params": 877961291,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_so400m_patch14_384/1",
+    },
+    "siglip_so400m_patch16_256_i18n": {
+        "metadata": {
+            "description": (
+                "1.1 billion parameter, image size 256, "
+                "shape-optimized version, pre-trained on WebLi."
+            ),
+            "params": 1128759282,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_so400m_patch16_256_i18n/1",
+    },
+    "siglip_base_patch16_256_multilingual": {
+        "metadata": {
+            "description": (
+                "370 million parameter, image size 256, pre-trained on WebLi."
+            ),
+            "params": 370626370,
+            "official_name": "SigLIP",
+            "path": "siglip",
+            "model_card": "https://www.kaggle.com/models/kerashub/siglip",
+        },
+        "kaggle_handle": "kaggle://kerashub/siglip/keras/siglip_base_patch16_256_multilingual/1",
+    },
+}

keras_hub/src/models/siglip/siglip_text_encoder.py

@@ -0,0 +1,134 @@
+from keras import initializers
+from keras import layers
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.siglip.siglip_layers import SigLIPEncoderLayer
+from keras_hub.src.models.siglip.siglip_layers import SigLIPTextEmbedding
+
+
+@keras_hub_export("keras_hub.models.SigLIPTextEncoder")
+class SigLIPTextEncoder(Backbone):
+    """SigLIP text core network with hyperparameters.
+
+    Args:
+        vocabulary_size: int. The size of the token vocabulary.
+        embedding_dim: int. The output dimension of the embedding layer.
+        hidden_dim: int. The size of the transformer hidden state at the end
+            of each transformer layer.
+        num_layers: int. The number of transformer layers.
+        num_heads: int. The number of attention heads for each transformer.
+        intermediate_dim: int. The output dimension of the first Dense layer in
+            a two-layer feedforward network for each transformer.
+        intermediate_activation: activation function. The activation that
+            is used for the first Dense layer in a two-layer feedforward network
+            for each transformer. Defaults to `"gelu_approximate"`.
+        layer_norm_epsilon: float. The epsilon for the layer normalization.
+            Defaults to `1e-6`.
+        max_sequence_length: int. The maximum sequence length that this encoder
+            can consume. Defaults to `64`.
+        dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
+            for the models computations and weights. Note that some
+            computations, such as softmax and layer normalization will always
+            be done a float32 precision regardless of dtype.
+    """
+
+    def __init__(
+        self,
+        vocabulary_size,
+        embedding_dim,
+        hidden_dim,
+        num_layers,
+        num_heads,
+        intermediate_dim,
+        intermediate_activation="gelu_approximate",
+        layer_norm_epsilon=1e-6,
+        max_sequence_length=64,
+        dtype=None,
+        name=None,
+        **kwargs,
+    ):
+        # `prefix` is used to prevent duplicate name when utilizing multiple
+        # SigLIP encoders within a single model.
+        prefix = str(name) + "_" if name is not None else ""
+
+        # === Layers ===
+        self.embedding = SigLIPTextEmbedding(
+            vocabulary_size=vocabulary_size,
+            sequence_length=max_sequence_length,
+            embedding_dim=embedding_dim,
+            dtype=dtype,
+            name=f"{prefix}embedding",
+        )
+        self.encoder_layers = [
+            SigLIPEncoderLayer(
+                hidden_dim,
+                num_heads,
+                intermediate_dim,
+                intermediate_activation,
+                layer_norm_epsilon=layer_norm_epsilon,
+                dtype=dtype,
+                name=f"{prefix}encoder_block_{i}",
+            )
+            for i in range(num_layers)
+        ]
+        self.post_layer_norm = layers.LayerNormalization(
+            epsilon=layer_norm_epsilon,
+            dtype=dtype,
+            name=f"{prefix}post_layer_norm",
+        )
+        self.head = layers.Dense(
+            hidden_dim,
+            kernel_initializer=initializers.LecunNormal(),
+            dtype=dtype,
+            name=f"{prefix}head",
+        )
+
+        # === Functional Model ===
+        token_id_input = layers.Input(
+            shape=(None,), dtype="int32", name="token_ids"
+        )
+        x = self.embedding(token_id_input)
+        for _, block in enumerate(self.encoder_layers):
+            x = block(x)
+        x = self.post_layer_norm(x)
+
+        # Assuming "sticky" EOS tokenization, last token is always EOS.
+        x = x[:, -1, :]
+        x = self.head(x)
+        outputs = x
+        super().__init__(
+            inputs={"token_ids": token_id_input},
+            outputs=outputs,
+            dtype=dtype,
+            name=name,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.vocabulary_size = vocabulary_size
+        self.embedding_dim = embedding_dim
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.intermediate_dim = intermediate_dim
+        self.intermediate_activation = intermediate_activation
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.max_sequence_length = max_sequence_length
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "vocabulary_size": self.vocabulary_size,
+                "embedding_dim": self.embedding_dim,
+                "hidden_dim": self.hidden_dim,
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "intermediate_dim": self.intermediate_dim,
+                "intermediate_activation": self.intermediate_activation,
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+                "max_sequence_length": self.max_sequence_length,
+            }
+        )
+        return config

keras_hub/src/models/siglip/siglip_tokenizer.py

@@ -0,0 +1,77 @@
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.siglip.siglip_backbone import SigLIPBackbone
+from keras_hub.src.tokenizers.sentence_piece_tokenizer import (
+    SentencePieceTokenizer,
+)
+
+
+@keras_hub_export(
+    [
+        "keras_hub.tokenizers.SigLIPTokenizer",
+        "keras_hub.models.SigLIPTokenizer",
+    ]
+)
+class SigLIPTokenizer(SentencePieceTokenizer):
+    """SigLIP 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
+    SigLIP models and provides a `from_preset()` method to automatically
+    download a matching vocabulary for a SigLIP preset.
+
+    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.SigLIPTokenizer.from_preset(
+        "siglip_base_patch16_224"
+    )
+    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."))
+
+    # Custom vocabulary.
+    bytes_io = io.BytesIO()
+    ds = tf.data.Dataset.from_tensor_slices(["The quick brown fox jumped."])
+    sentencepiece.SentencePieceTrainer.train(
+        sentence_iterator=ds.as_numpy_iterator(),
+        model_writer=bytes_io,
+        vocab_size=8,
+        model_type="WORD",
+        pad_id=0,
+        bos_id=1,
+        eos_id=2,
+        unk_id=3,
+        unk_piece="<unk>",
+    )
+    tokenizer = keras_hub.models.SigLIPTokenizer(
+        proto=bytes_io.getvalue(),
+    )
+    tokenizer("The quick brown fox jumped.")
+    ```
+    """
+
+    backbone_cls = SigLIPBackbone
+
+    def __init__(self, proto, **kwargs):
+        self._add_special_token("<unk>", "unknown_token")
+        self._add_special_token("</s>", "end_token")
+        self._add_special_token("</s>", "pad_token")
+        super().__init__(proto=proto, **kwargs)

keras_hub/src/models/siglip/siglip_vision_encoder.py

@@ -0,0 +1,151 @@
+from keras import layers
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.models.backbone import Backbone
+from keras_hub.src.models.siglip.siglip_layers import SigLIPEncoderLayer
+from keras_hub.src.models.siglip.siglip_layers import (
+    SigLIPMultiHeadAttentionPooling,
+)
+from keras_hub.src.models.siglip.siglip_layers import SigLIPVisionEmbedding
+from keras_hub.src.utils.keras_utils import standardize_data_format
+
+
+@keras_hub_export("keras_hub.models.SigLIPVisionEncoder")
+class SigLIPVisionEncoder(Backbone):
+    """SigLIP vision core network with hyperparameters.
+
+    Args:
+        patch_size: int. The size of each square patch in the input image.
+        hidden_dim: int. The size of the transformer hidden state at the end
+            of each transformer layer.
+        num_layers: int. The number of transformer layers.
+        num_heads: int. The number of attention heads for each transformer.
+        intermediate_dim: int. The output dimension of the first Dense layer in
+            a two-layer feedforward network for each transformer.
+        intermediate_activation: activation function. The activation that
+            is used for the first Dense layer in a two-layer feedforward network
+            for each transformer. Defaults to `"gelu_approximate"`.
+        layer_norm_epsilon: float. The epsilon for the layer normalization.
+            Defaults to `1e-6`.
+        image_shape: tuple. The input shape without the batch size. Defaults to
+            `(224, 224, 3)`.
+        data_format: `None` or str. If specified, either `"channels_last"` or
+            `"channels_first"`. The ordering of the dimensions in the
+            inputs. `"channels_last"` corresponds to inputs with shape
+            `(batch_size, height, width, channels)`
+            while `"channels_first"` corresponds to inputs with shape
+            `(batch_size, channels, height, width)`. It defaults to the
+            `image_data_format` value found in your Keras config file at
+            `~/.keras/keras.json`. If you never set it, then it will be
+            `"channels_last"`.
+        dtype: string or `keras.mixed_precision.DTypePolicy`. The dtype to use
+            for the models computations and weights. Note that some
+            computations, such as softmax and layer normalization will always
+            be done a float32 precision regardless of dtype.
+    """
+
+    def __init__(
+        self,
+        patch_size,
+        hidden_dim,
+        num_layers,
+        num_heads,
+        intermediate_dim,
+        intermediate_activation="gelu_approximate",
+        layer_norm_epsilon=1e-6,
+        image_shape=(224, 224, 3),
+        data_format=None,
+        dtype=None,
+        name=None,
+        **kwargs,
+    ):
+        data_format = standardize_data_format(data_format)
+        if data_format == "channels_last":
+            height, width = image_shape[0], image_shape[1]
+        else:
+            height, width = image_shape[1], image_shape[2]
+        if height != width:
+            raise ValueError(
+                "`SigLIPVisionEncoder` expects the height and width to be the "
+                f"same in `image_shape`. Received: image_shape={image_shape}"
+            )
+
+        # `prefix` is used to prevent duplicate name when utilizing multiple
+        # SigLIP encoders within a single model.
+        prefix = str(name) + "_" if name is not None else ""
+
+        # === Layers ===
+        self.embedding = SigLIPVisionEmbedding(
+            hidden_dim=hidden_dim,
+            patch_size=patch_size,
+            image_size=height,
+            data_format=data_format,
+            dtype=dtype,
+            name=f"{prefix}embedding",
+        )
+        self.encoder_layers = [
+            SigLIPEncoderLayer(
+                hidden_dim,
+                num_heads,
+                intermediate_dim,
+                intermediate_activation,
+                layer_norm_epsilon=layer_norm_epsilon,
+                dtype=dtype,
+                name=f"{prefix}encoder_block_{i}",
+            )
+            for i in range(num_layers)
+        ]
+        self.post_layer_norm = layers.LayerNormalization(
+            epsilon=1e-6, dtype=dtype, name=f"{prefix}post_layer_norm"
+        )
+        self.head = SigLIPMultiHeadAttentionPooling(
+            hidden_dim,
+            intermediate_dim,
+            num_heads,
+            intermediate_activation,
+            layer_norm_epsilon,
+            dtype=dtype,
+            name=f"{prefix}head",
+        )
+
+        # === Functional Model ===
+        image_input = layers.Input(shape=image_shape, name="images")
+        x = self.embedding(image_input)
+        for _, block in enumerate(self.encoder_layers):
+            x = block(x)
+        x = self.post_layer_norm(x)
+        x = self.head(x)
+        outputs = x
+        super().__init__(
+            inputs={"images": image_input},
+            outputs=outputs,
+            dtype=dtype,
+            name=name,
+            **kwargs,
+        )
+
+        # === Config ===
+        self.patch_size = patch_size
+        self.hidden_dim = hidden_dim
+        self.num_layers = num_layers
+        self.num_heads = num_heads
+        self.intermediate_dim = intermediate_dim
+        self.intermediate_activation = intermediate_activation
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.image_shape = image_shape
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "patch_size": self.patch_size,
+                "hidden_dim": self.hidden_dim,
+                "num_layers": self.num_layers,
+                "num_heads": self.num_heads,
+                "intermediate_dim": self.intermediate_dim,
+                "intermediate_activation": self.intermediate_activation,
+                "layer_norm_epsilon": self.layer_norm_epsilon,
+                "image_shape": self.image_shape,
+            }
+        )
+        return config

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.19.0.dev202503020350"
+__version__ = "0.19.0.dev202503040351"
 
 
 @keras_hub_export("keras_hub.version")

{keras_hub_nightly-0.19.0.dev202503020350.dist-info → keras_hub_nightly-0.19.0.dev202503040351.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: keras-hub-nightly
-Version: 0.19.0.dev202503020350
+Version: 0.19.0.dev202503040351
 Summary: Industry-strength Natural Language Processing extensions for Keras.
 Home-page: https://github.com/keras-team/keras-hub
 Author: Keras team