keras-hub-nightly 0.15.0.dev20240823171555__py3-none-any.whl

keras_hub/src/layers/preprocessing/random_swap.py

@@ -0,0 +1,267 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 random
+
+from keras_hub.src.api_export import keras_hub_export
+from keras_hub.src.layers.preprocessing.preprocessing_layer import (
+    PreprocessingLayer,
+)
+from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+from keras_hub.src.utils.tensor_utils import is_int_dtype
+from keras_hub.src.utils.tensor_utils import is_string_dtype
+
+try:
+    import tensorflow as tf
+except ImportError:
+    tf = None
+
+
+@keras_hub_export("keras_hub.layers.RandomSwap")
+class RandomSwap(PreprocessingLayer):
+    """Augments input by randomly swapping words.
+
+    This layer comes in handy when you need to generate new data using swap
+    augmentations as described in the paper [EDA: Easy Data Augmentation
+    Techniques for Boosting Performance on Text Classification Tasks]
+    (https://arxiv.org/pdf/1901.11196.pdf). The layer expects the inputs to be
+    pre-split into token level inputs. This allows control over the level of
+    augmentation, you can split by character for character level swaps, or by
+    word for word level swaps.
+
+    Input data should be passed as tensors, `tf.RaggedTensor`s, or lists. For
+    batched input, inputs should be a list of lists or a rank two tensor. For
+    unbatched inputs, each element should be a list or a rank one tensor.
+
+    Args:
+        rate: The probability of a given token being chosen to be swapped
+            with another random token.
+        max_swaps: The maximum number of swaps to be performed.
+        skip_list: A list of token values that should not be considered
+            candidates for deletion.
+        skip_fn: A function that takes as input a scalar tensor token and
+            returns as output a scalar tensor True/False value. A value of
+            True indicates that the token should not be considered a
+            candidate for deletion. This function must be tracable--it
+            should consist of tensorflow operations.
+        skip_py_fn: A function that takes as input a python token value and
+            returns as output `True` or `False`. A value of True
+            indicates that should not be considered a candidate for deletion.
+            Unlike the `skip_fn` argument, this argument need not be
+            tracable--it can be any python function.
+        seed: A seed for the random number generator.
+
+
+    Examples:
+
+    Word level usage.
+    >>> keras.utils.set_random_seed(1337)
+    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
+    >>> augmenter=keras_hub.layers.RandomSwap(rate=0.4, seed=42)
+    >>> augmented=augmenter(inputs)
+    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
+    <tf.Tensor: shape=(2,), dtype=string,
+    numpy=array([b'like I Hey', b'and Keras Tensorflow'], dtype=object)>
+
+    Character level usage.
+    >>> keras.utils.set_random_seed(1337)
+    >>> inputs=tf.strings.unicode_split(["Hey Dude", "Speed Up"], "UTF-8")
+    >>> augmenter=keras_hub.layers.RandomSwap(rate=0.4, seed=42)
+    >>> augmented=augmenter(inputs)
+    >>> tf.strings.reduce_join(augmented, axis=-1)
+    <tf.Tensor: shape=(2,), dtype=string,
+    numpy=array([b'deD yuHe', b'SUede pp'], dtype=object)>
+
+    Usage with skip_list.
+    >>> keras.utils.set_random_seed(1337)
+    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
+    >>> augmenter=keras_hub.layers.RandomSwap(rate=0.4,
+    ...     skip_list=["Keras"], seed=42)
+    >>> augmented=augmenter(inputs)
+    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
+    <tf.Tensor: shape=(2,), dtype=string,
+    numpy=array([b'like I Hey', b'Keras and Tensorflow'], dtype=object)>
+
+    Usage with skip_fn.
+    >>> def skip_fn(word):
+    ...     return tf.strings.regex_full_match(word, r"[I, a].*")
+    >>> keras.utils.set_random_seed(1337)
+    >>> inputs=tf.strings.split(["Hey I like", "Keras and Tensorflow"])
+    >>> augmenter=keras_hub.layers.RandomSwap(rate=0.9, max_swaps=3,
+    ...     skip_fn=skip_fn, seed=11)
+    >>> augmented=augmenter(inputs)
+    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
+    <tf.Tensor: shape=(2,), dtype=string,
+    numpy=array([b'like I Hey', b'Keras and Tensorflow'], dtype=object)>
+
+    Usage with skip_py_fn.
+    >>> def skip_py_fn(word):
+    ...     return len(word) < 4
+    >>> keras.utils.set_random_seed(1337)
+    >>> inputs=tf.strings.split(["He was drifting along", "With the wind"])
+    >>> augmenter=keras_hub.layers.RandomSwap(rate=0.8, max_swaps=2,
+    ...     skip_py_fn=skip_py_fn, seed=15)
+    >>> augmented=augmenter(inputs)
+    >>> tf.strings.reduce_join(augmented, separator=" ", axis=-1)
+    <tf.Tensor: shape=(2,), dtype=string, numpy=array([b'He was along drifting',
+    b'wind the With'], dtype=object)>
+    """
+
+    def __init__(
+        self,
+        rate,
+        max_swaps=None,
+        skip_list=None,
+        skip_fn=None,
+        skip_py_fn=None,
+        seed=None,
+        name=None,
+        dtype="int32",
+        **kwargs,
+    ):
+        if not is_int_dtype(dtype) and not is_string_dtype(dtype):
+            raise ValueError(
+                "Output dtype must be an integer type or a string. "
+                f"Received: dtype={dtype}"
+            )
+
+        super().__init__(name=name, dtype=dtype, **kwargs)
+
+        self.rate = rate
+        self.max_swaps = max_swaps
+        self.seed = random.randint(1, 1e9) if seed is None else seed
+        self._generator = tf.random.Generator.from_seed(self.seed)
+        self.skip_list = skip_list
+        self.skip_fn = skip_fn
+        self.skip_py_fn = skip_py_fn
+        if self.max_swaps is not None and self.max_swaps < 0:
+            raise ValueError(
+                "max_swaps must be non-negative."
+                f"Received max_swaps={max_swaps}."
+            )
+
+        if [self.skip_list, self.skip_fn, self.skip_py_fn].count(None) < 2:
+            raise ValueError(
+                "Exactly one of skip_list, skip_fn, skip_py_fn must be "
+                "provided."
+            )
+
+        if self.skip_list:
+            self.StaticHashTable = tf.lookup.StaticHashTable(
+                tf.lookup.KeyValueTensorInitializer(
+                    tf.convert_to_tensor(self.skip_list),
+                    tf.convert_to_tensor([True] * len(self.skip_list)),
+                ),
+                default_value=False,
+            )
+
+    def call(self, inputs):
+        inputs, unbatched, _ = convert_to_ragged_batch(inputs)
+
+        skip_masks = None
+        if self.skip_list:
+            skip_masks = self.StaticHashTable.lookup(inputs.flat_values)
+        elif self.skip_fn:
+            skip_masks = tf.map_fn(
+                self.skip_fn, inputs.flat_values, fn_output_signature="bool"
+            )
+        elif self.skip_py_fn:
+
+            def string_fn(token):
+                return self.skip_py_fn(token.numpy().decode("utf-8"))
+
+            def int_fn(token):
+                return self.skip_py_fn(token.numpy())
+
+            py_fn = string_fn if inputs.dtype == tf.string else int_fn
+
+            skip_masks = tf.map_fn(
+                lambda x: tf.py_function(py_fn, [x], "bool"),
+                inputs.flat_values,
+                fn_output_signature="bool",
+            )
+
+        positions = tf.ragged.range(inputs.row_lengths())
+
+        if skip_masks is not None:
+            skip_masks = tf.logical_not(skip_masks)
+            skip_masks.set_shape([None])
+            positions = tf.ragged.boolean_mask(
+                positions, inputs.with_flat_values(skip_masks)
+            )
+        # Figure out how many we are going to select.
+        token_counts = tf.cast(positions.row_lengths(), "float32")
+        num_to_select = tf.random.stateless_binomial(
+            shape=tf.shape(token_counts),
+            seed=self._generator.make_seeds()[:, 0],
+            counts=token_counts,
+            probs=self.rate,
+        )
+        if self.max_swaps is not None:
+            num_to_select = tf.math.minimum(num_to_select, self.max_swaps)
+        num_to_select = tf.math.minimum(
+            num_to_select, tf.cast(positions.row_lengths(), "int32")
+        )
+        num_to_select = tf.cast(num_to_select, "int64")
+
+        def _swap(x):
+            positions, inputs, num_to_select = x
+            for _ in range(num_to_select):
+                index = tf.random.stateless_uniform(
+                    shape=[2],
+                    minval=0,
+                    maxval=tf.size(positions),
+                    dtype="int32",
+                    seed=self._generator.make_seeds()[:, 0],
+                )
+                index1, index2 = positions[index[0]], positions[index[1]]
+                # swap items at the sampled indices with each other
+                inputs = tf.tensor_scatter_nd_update(
+                    inputs,
+                    [[index1], [index2]],
+                    [inputs[index2], inputs[index1]],
+                )
+            return inputs
+
+        swapped = tf.map_fn(
+            _swap,
+            (positions, inputs, num_to_select),
+            fn_output_signature=tf.RaggedTensorSpec(
+                ragged_rank=positions.ragged_rank - 1, dtype=inputs.dtype
+            ),
+        )
+        swapped.flat_values.set_shape([None])
+
+        if unbatched:
+            swapped = tf.squeeze(swapped, axis=0)
+        return swapped
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "rate": self.rate,
+                "max_swaps": self.max_swaps,
+                "seed": self.seed,
+                "skip_list": self.skip_list,
+                "skip_fn": self.skip_fn,
+                "skip_py_fn": self.skip_py_fn,
+            }
+        )
+        return config
+
+    def compute_output_shape(self, inputs_shape):
+        inputs_shape = list(inputs_shape)
+        inputs_shape[-1] = None
+        return tuple(inputs_shape)

keras_hub/src/layers/preprocessing/start_end_packer.py

@@ -0,0 +1,219 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.api_export import keras_hub_export
+from keras_hub.src.layers.preprocessing.preprocessing_layer import (
+    PreprocessingLayer,
+)
+from keras_hub.src.utils.tensor_utils import convert_to_ragged_batch
+
+try:
+    import tensorflow as tf
+except ImportError:
+    tf = None
+
+
+@keras_hub_export("keras_hub.layers.StartEndPacker")
+class StartEndPacker(PreprocessingLayer):
+    """Adds start and end tokens to a sequence and pads to a fixed length.
+
+    This layer is useful when tokenizing inputs for tasks like translation,
+    where each sequence should include a start and end marker. It should
+    be called after tokenization. The layer will first trim inputs to fit, then
+    add start/end tokens, and finally pad, if necessary, to `sequence_length`.
+
+    Input data should be passed as tensors, `tf.RaggedTensor`s, or lists. For
+    batched input, inputs should be a list of lists or a rank two tensor. For
+    unbatched inputs, each element should be a list or a rank one tensor.
+
+    Args:
+        sequence_length: int. The desired output length.
+        start_value: int/str/list/tuple. The ID(s) or token(s) that are to be
+            placed at the start of each sequence. The dtype must match the dtype
+            of the input tensors to the layer. If `None`, no start value will be
+            added.
+        end_value: int/str/list/tuple. The ID(s) or token(s) that are to be
+            placed at the end of each input segment. The dtype must match the
+            dtype of the input tensors to the layer. If `None`, no end value
+            will be added.
+        pad_value: int/str. The ID or token that is to be placed into the
+            unused positions after the last segment in the sequence. If `None`,
+            0 or "" will be added depending on the dtype of the input tensor.
+        return_padding_mask: bool. Whether to return a boolean padding mask of
+            all locations that are filled in with the `pad_value`.
+
+    Call arguments:
+        inputs: A `tf.Tensor`, `tf.RaggedTensor`, or list of python strings.
+        sequence_length: Pass to override the configured `sequence_length` of
+            the layer.
+        add_start_value: Pass `False` to not append a start value for this
+            input.
+        add_end_value: Pass `False` to not append an end value for this
+            input.
+
+    Examples:
+
+    Unbatched input (int).
+    >>> inputs = [5, 6, 7]
+    >>> start_end_packer = keras_hub.layers.StartEndPacker(
+    ...     sequence_length=7, start_value=1, end_value=2,
+    ... )
+    >>> outputs = start_end_packer(inputs)
+    >>> np.array(outputs)
+    array([1, 5, 6, 7, 2, 0, 0], dtype=int32)
+
+    Batched input (int).
+    >>> inputs = [[5, 6, 7], [8, 9, 10, 11, 12, 13, 14]]
+    >>> start_end_packer = keras_hub.layers.StartEndPacker(
+    ...     sequence_length=6, start_value=1, end_value=2,
+    ... )
+    >>> outputs = start_end_packer(inputs)
+    >>> np.array(outputs)
+    array([[ 1,  5,  6,  7,  2,  0],
+           [ 1,  8,  9, 10, 11,  2]], dtype=int32)
+
+    Unbatched input (str).
+    >>> inputs = tf.constant(["this", "is", "fun"])
+    >>> start_end_packer = keras_hub.layers.StartEndPacker(
+    ...     sequence_length=6, start_value="<s>", end_value="</s>",
+    ...     pad_value="<pad>"
+    ... )
+    >>> outputs = start_end_packer(inputs)
+    >>> np.array(outputs).astype("U")
+    array(['<s>', 'this', 'is', 'fun', '</s>', '<pad>'], dtype='<U5')
+
+    Batched input (str).
+    >>> inputs = tf.ragged.constant([["this", "is", "fun"], ["awesome"]])
+    >>> start_end_packer = keras_hub.layers.StartEndPacker(
+    ...     sequence_length=6, start_value="<s>", end_value="</s>",
+    ...     pad_value="<pad>"
+    ... )
+    >>> outputs = start_end_packer(inputs)
+    >>> np.array(outputs).astype("U")
+    array([['<s>', 'this', 'is', 'fun', '</s>', '<pad>'],
+           ['<s>', 'awesome', '</s>', '<pad>', '<pad>', '<pad>']], dtype='<U7')
+
+    Multiple start tokens.
+    >>> inputs = tf.ragged.constant([["this", "is", "fun"], ["awesome"]])
+    >>> start_end_packer = keras_hub.layers.StartEndPacker(
+    ...     sequence_length=6, start_value=["</s>", "<s>"], end_value="</s>",
+    ...     pad_value="<pad>"
+    ... )
+    >>> outputs = start_end_packer(inputs)
+    >>> np.array(outputs).astype("U")
+    array([['</s>', '<s>', 'this', 'is', 'fun', '</s>'],
+           ['</s>', '<s>', 'awesome', '</s>', '<pad>', '<pad>']], dtype='<U7')
+    """
+
+    def __init__(
+        self,
+        sequence_length,
+        start_value=None,
+        end_value=None,
+        pad_value=None,
+        return_padding_mask=False,
+        name=None,
+        **kwargs,
+    ):
+        super().__init__(name=name, **kwargs)
+
+        self.sequence_length = sequence_length
+
+        # Maintain private copies for config purposes.
+        self._start_value = start_value
+        self._end_value = end_value
+
+        def check_special_value_type(value, value_name):
+            if isinstance(value, (int, str)):
+                return [value]
+            if value and not isinstance(value, (list, tuple)):
+                raise ValueError(
+                    f"{value_name} should be of type int/str/list/tuple."
+                    f"Received type: `{type(value)}`."
+                )
+            return value
+
+        start_value = check_special_value_type(start_value, "start_value")
+        end_value = check_special_value_type(end_value, "end_value")
+
+        self.start_value = start_value
+        self.end_value = end_value
+
+        self.pad_value = pad_value
+        self.return_padding_mask = return_padding_mask
+
+    def call(
+        self,
+        inputs,
+        sequence_length=None,
+        add_start_value=True,
+        add_end_value=True,
+    ):
+        inputs, unbatched, _ = convert_to_ragged_batch(inputs)
+
+        x = inputs  # Intermediate result.
+
+        batch_size = tf.shape(x)[0]
+        sequence_length = sequence_length or self.sequence_length
+        dtype = inputs.dtype
+
+        # Concatenate start and end tokens.
+        if add_start_value and self.start_value is not None:
+            start_value = tf.convert_to_tensor(self.start_value, dtype=dtype)
+            start_token_id_tensor = tf.repeat(
+                start_value[tf.newaxis, :], repeats=batch_size, axis=0
+            )
+            x = tf.concat([start_token_id_tensor, x], axis=-1)
+        if add_end_value and self.end_value is not None:
+            end_value = tf.convert_to_tensor(self.end_value, dtype=dtype)
+            end_token_id_tensor = tf.repeat(
+                end_value[tf.newaxis, :], repeats=batch_size, axis=0
+            )
+            # Trim to leave room for end token.
+            x = x[..., : sequence_length - len(self.end_value)]
+            x = tf.concat([x, end_token_id_tensor], axis=-1)
+
+        # Pad to desired length.
+        outputs = x.to_tensor(
+            default_value=self.pad_value,
+            shape=(batch_size, sequence_length),
+        )
+        outputs = tf.squeeze(outputs, axis=0) if unbatched else outputs
+
+        if self.return_padding_mask:
+            mask = tf.ones_like(x, dtype="bool")
+            mask = mask.to_tensor(shape=(batch_size, sequence_length))
+            mask = tf.squeeze(mask, axis=0) if unbatched else mask
+            return outputs, mask
+
+        return outputs
+
+    def get_config(self):
+        config = super().get_config()
+        config.update(
+            {
+                "sequence_length": self.sequence_length,
+                "start_value": self._start_value,
+                "end_value": self._end_value,
+                "pad_value": self.pad_value,
+                "return_padding_mask": self.return_padding_mask,
+            }
+        )
+        return config
+
+    def compute_output_shape(self, inputs_shape):
+        inputs_shape = list(inputs_shape)
+        inputs_shape[-1] = self.sequence_length
+        return tuple(inputs_shape)

keras_hub/src/metrics/__init__.py

@@ -0,0 +1,13 @@
+# Copyright 2024 The KerasHub Authors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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.