tf-keras-nightly 2.19.0.dev2024121210__py3-none-any.whl → 2.21.0.dev2025123010__py3-none-any.whl

tf_keras/src/layers/preprocessing/benchmarks/embedding_dense_benchmark.py

@@ -1,86 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for KPL implementation of embedding column with dense inputs."""
-
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing.benchmarks import (
-    feature_column_benchmark as fc_bm,
-)
-
-# isort: off
-from tensorflow.python.eager.def_function import (
-    function as tf_function,
-)
-
-NUM_REPEATS = 10
-BATCH_SIZES = [32, 256]
-
-
-### KPL AND FC IMPLEMENTATION BENCHMARKS ###
-def embedding_varlen(batch_size, max_length):
-    """Benchmark a variable-length embedding."""
-    # Data and constants.
-    embedding_size = 32768
-    data = fc_bm.create_data(
-        max_length, batch_size * NUM_REPEATS, embedding_size - 1, dtype=int
-    )
-
-    # TF-Keras implementation
-    model = keras.Sequential()
-    model.add(keras.Input(shape=(None,), name="data", dtype=tf.int64))
-    model.add(keras.layers.Embedding(embedding_size, 256))
-    model.add(keras.layers.Lambda(lambda x: tf.reduce_mean(x, axis=-1)))
-
-    # FC implementation
-    fc = tf.feature_column.embedding_column(
-        tf.feature_column.categorical_column_with_identity(
-            "data", num_buckets=embedding_size - 1
-        ),
-        dimension=256,
-    )
-
-    # Wrap the FC implementation in a tf.function for a fair comparison
-    @tf_function()
-    def fc_fn(tensors):
-        fc.transform_feature(
-            tf.__internal__.feature_column.FeatureTransformationCache(tensors),
-            None,
-        )
-
-    # Benchmark runs
-    keras_data = {"data": data.to_tensor(default_value=0)}
-    k_avg_time = fc_bm.run_keras(keras_data, model, batch_size, NUM_REPEATS)
-
-    fc_data = {"data": data.to_tensor(default_value=0)}
-    fc_avg_time = fc_bm.run_fc(fc_data, fc_fn, batch_size, NUM_REPEATS)
-
-    return k_avg_time, fc_avg_time
-
-
-class BenchmarkLayer(fc_bm.LayerBenchmark):
-    """Benchmark the layer forward pass."""
-
-    def benchmark_layer(self):
-        for batch in BATCH_SIZES:
-            name = f"embedding|dense|batch_{batch}"
-            k_time, f_time = embedding_varlen(batch_size=batch, max_length=256)
-            self.report(name, k_time, f_time, NUM_REPEATS)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

tf_keras/src/layers/preprocessing/benchmarks/embedding_varlen_benchmark.py

@@ -1,89 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for KPL implementation of embedding column with varying-length
-inputs."""
-
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing.benchmarks import (
-    feature_column_benchmark as fc_bm,
-)
-
-# isort: off
-from tensorflow.python.eager.def_function import (
-    function as tf_function,
-)
-
-NUM_REPEATS = 10
-BATCH_SIZES = [32, 256]
-
-
-### KPL AND FC IMPLEMENTATION BENCHMARKS ###
-def embedding_varlen(batch_size, max_length):
-    """Benchmark a variable-length embedding."""
-    # Data and constants.
-    embedding_size = 32768
-    data = fc_bm.create_data(
-        max_length, batch_size * NUM_REPEATS, embedding_size - 1, dtype=int
-    )
-
-    # TF-Keras implementation
-    model = keras.Sequential()
-    model.add(
-        keras.Input(shape=(None,), ragged=True, name="data", dtype=tf.int64)
-    )
-    model.add(keras.layers.Embedding(embedding_size, 256))
-    model.add(keras.layers.Lambda(lambda x: tf.reduce_mean(x, axis=-1)))
-
-    # FC implementation
-    fc = tf.feature_column.embedding_column(
-        tf.feature_column.categorical_column_with_identity(
-            "data", num_buckets=embedding_size - 1
-        ),
-        dimension=256,
-    )
-
-    # Wrap the FC implementation in a tf.function for a fair comparison
-    @tf_function()
-    def fc_fn(tensors):
-        fc.transform_feature(
-            tf.__internal__.feature_column.FeatureTransformationCache(tensors),
-            None,
-        )
-
-    # Benchmark runs
-    keras_data = {"data": data}
-    k_avg_time = fc_bm.run_keras(keras_data, model, batch_size, NUM_REPEATS)
-
-    fc_data = {"data": data.to_sparse()}
-    fc_avg_time = fc_bm.run_fc(fc_data, fc_fn, batch_size, NUM_REPEATS)
-
-    return k_avg_time, fc_avg_time
-
-
-class BenchmarkLayer(fc_bm.LayerBenchmark):
-    """Benchmark the layer forward pass."""
-
-    def benchmark_layer(self):
-        for batch in BATCH_SIZES:
-            name = f"embedding|varlen|batch_{batch}"
-            k_time, f_time = embedding_varlen(batch_size=batch, max_length=256)
-            self.report(name, k_time, f_time, NUM_REPEATS)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

tf_keras/src/layers/preprocessing/benchmarks/hashed_crossing_benchmark.py

@@ -1,90 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for KPL implementation of categorical cross hash columns with dense
-inputs."""
-
-
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing import hashed_crossing
-from tf_keras.src.layers.preprocessing.benchmarks import (
-    feature_column_benchmark as fc_bm,
-)
-
-# isort: off
-from tensorflow.python.eager.def_function import (
-    function as tf_function,
-)
-
-NUM_REPEATS = 10
-BATCH_SIZES = [32, 256]
-
-
-def embedding_varlen(batch_size):
-    """Benchmark a variable-length embedding."""
-    # Data and constants.
-    num_buckets = 10000
-    data_a = tf.random.uniform(
-        shape=(batch_size * NUM_REPEATS, 1), maxval=32768, dtype=tf.int64
-    )
-    data_b = tf.strings.as_string(data_a)
-
-    # TF-Keras implementation
-    input_1 = keras.Input(shape=(1,), name="data_a", dtype=tf.int64)
-    input_2 = keras.Input(shape=(1,), name="data_b", dtype=tf.string)
-    outputs = hashed_crossing.HashedCrossing(num_buckets)([input_1, input_2])
-    model = keras.Model([input_1, input_2], outputs)
-
-    # FC implementation
-    fc = tf.feature_column.crossed_column(["data_a", "data_b"], num_buckets)
-
-    # Wrap the FC implementation in a tf.function for a fair comparison
-    @tf_function()
-    def fc_fn(tensors):
-        fc.transform_feature(
-            tf.__internal__.feature_column.FeatureTransformationCache(tensors),
-            None,
-        )
-
-    # Benchmark runs
-    keras_data = {
-        "data_a": data_a,
-        "data_b": data_b,
-    }
-    k_avg_time = fc_bm.run_keras(keras_data, model, batch_size, NUM_REPEATS)
-
-    fc_data = {
-        "data_a": data_a,
-        "data_b": data_b,
-    }
-    fc_avg_time = fc_bm.run_fc(fc_data, fc_fn, batch_size, NUM_REPEATS)
-
-    return k_avg_time, fc_avg_time
-
-
-class BenchmarkLayer(fc_bm.LayerBenchmark):
-    """Benchmark the layer forward pass."""
-
-    def benchmark_layer(self):
-        for batch in BATCH_SIZES:
-            name = f"hashed_cross|dense|batch_{batch}"
-            k_time, f_time = embedding_varlen(batch_size=batch)
-            self.report(name, k_time, f_time, NUM_REPEATS)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

tf_keras/src/layers/preprocessing/benchmarks/hashing_benchmark.py

@@ -1,105 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for TF-Keras hashing preprocessing layer."""
-
-import itertools
-import random
-import string
-import time
-
-import numpy as np
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing import hashing
-
-
-# word_gen creates random sequences of ASCII letters (both lowercase and upper).
-# The number of unique strings is ~2,700.
-def word_gen():
-    for _ in itertools.count(1):
-        yield "".join(random.choice(string.ascii_letters) for i in range(2))
-
-
-class BenchmarkLayer(tf.test.Benchmark):
-    """Benchmark the layer forward pass."""
-
-    def run_dataset_implementation(self, batch_size):
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            ds = tf.data.Dataset.from_generator(
-                word_gen, tf.string, tf.TensorShape([])
-            )
-            ds = ds.shuffle(batch_size * 100)
-            ds = ds.batch(batch_size)
-            num_batches = 5
-            ds = ds.take(num_batches)
-            ds = ds.prefetch(num_batches)
-            starts.append(time.time())
-            # Benchmarked code begins here.
-            for i in ds:
-                _ = tf.strings.to_hash_bucket(i, num_buckets=2)
-            # Benchmarked code ends here.
-            ends.append(time.time())
-
-        avg_time = np.mean(np.array(ends) - np.array(starts)) / num_batches
-        return avg_time
-
-    def bm_layer_implementation(self, batch_size):
-        input_1 = keras.Input(shape=(None,), dtype=tf.string, name="word")
-        layer = hashing.Hashing(num_bins=2)
-        _ = layer(input_1)
-
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            ds = tf.data.Dataset.from_generator(
-                word_gen, tf.string, tf.TensorShape([])
-            )
-            ds = ds.shuffle(batch_size * 100)
-            ds = ds.batch(batch_size)
-            num_batches = 5
-            ds = ds.take(num_batches)
-            ds = ds.prefetch(num_batches)
-            starts.append(time.time())
-            # Benchmarked code begins here.
-            for i in ds:
-                _ = layer(i)
-            # Benchmarked code ends here.
-            ends.append(time.time())
-
-        avg_time = np.mean(np.array(ends) - np.array(starts)) / num_batches
-        name = f"hashing|batch_{batch_size}"
-        baseline = self.run_dataset_implementation(batch_size)
-        extras = {
-            "dataset implementation baseline": baseline,
-            "delta seconds": (baseline - avg_time),
-            "delta percent": ((baseline - avg_time) / baseline) * 100,
-        }
-        self.report_benchmark(
-            iters=num_repeats, wall_time=avg_time, extras=extras, name=name
-        )
-
-    def benchmark_vocab_size_by_batch(self):
-        for batch in [32, 64, 256]:
-            self.bm_layer_implementation(batch_size=batch)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

tf_keras/src/layers/preprocessing/benchmarks/image_preproc_benchmark.py

@@ -1,159 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for TF-Keras image preprocessing layer."""
-
-import functools
-import time
-
-import numpy as np
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing import image_preprocessing
-
-LOWER = 0.2
-UPPER = 0.4
-BATCH_SIZE = 32
-
-
-def rotate(inputs):
-    """rotate image."""
-    inputs_shape = tf.shape(inputs)
-    batch_size = inputs_shape[0]
-    img_hd = tf.cast(inputs_shape[1], tf.float32)
-    img_wd = tf.cast(inputs_shape[2], tf.float32)
-    min_angle = LOWER * 2.0 * np.pi
-    max_angle = UPPER * 2.0 * np.pi
-    angles = tf.random.uniform(
-        shape=[batch_size], minval=min_angle, maxval=max_angle
-    )
-    return image_preprocessing.transform(
-        inputs, image_preprocessing.get_rotation_matrix(angles, img_hd, img_wd)
-    )
-
-
-def zoom(inputs):
-    """zoom image."""
-    inputs_shape = tf.shape(inputs)
-    batch_size = inputs_shape[0]
-    img_hd = tf.cast(inputs_shape[1], tf.float32)
-    img_wd = tf.cast(inputs_shape[2], tf.float32)
-    height_zoom = tf.random.uniform(
-        shape=[batch_size, 1], minval=1.0 + LOWER, maxval=1.0 + UPPER
-    )
-    width_zoom = tf.random.uniform(
-        shape=[batch_size, 1], minval=1.0 + LOWER, maxval=1.0 + UPPER
-    )
-    zooms = tf.cast(
-        tf.concat([width_zoom, height_zoom], axis=1), dtype=tf.float32
-    )
-    return image_preprocessing.transform(
-        inputs, image_preprocessing.get_zoom_matrix(zooms, img_hd, img_wd)
-    )
-
-
-def image_augmentation(inputs, batch_size):
-    """image augmentation."""
-    img = inputs
-    img = tf.image.resize(img, size=[224, 224])
-    img = tf.image.random_crop(img, size=[batch_size, 224, 224, 3])
-    img = rotate(img)
-    img = zoom(img)
-    return img
-
-
-class BenchmarkLayer(tf.test.Benchmark):
-    """Benchmark the layer forward pass."""
-
-    def run_dataset_implementation(self, batch_size):
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            ds = tf.data.Dataset.from_tensor_slices(
-                np.random.random((batch_size, 256, 256, 3))
-            )
-            ds = ds.shuffle(batch_size * 100)
-            ds = ds.batch(batch_size)
-            ds = ds.prefetch(batch_size)
-            img_augmentation = functools.partial(
-                image_augmentation, batch_size=batch_size
-            )
-            ds = ds.map(img_augmentation, num_parallel_calls=8)
-            starts.append(time.time())
-            count = 0
-            # Benchmarked code begins here.
-            for i in ds:
-                _ = i
-                count += 1
-            # Benchmarked code ends here.
-            ends.append(time.time())
-
-        avg_time = np.mean(np.array(ends) - np.array(starts)) / count
-        return avg_time
-
-    def bm_layer_implementation(self, batch_size):
-        with tf.device("/gpu:0"):
-            img = keras.Input(shape=(256, 256, 3), dtype=tf.float32)
-            preprocessor = keras.Sequential(
-                [
-                    image_preprocessing.Resizing(224, 224),
-                    image_preprocessing.RandomCrop(height=224, width=224),
-                    image_preprocessing.RandomRotation(factor=(0.2, 0.4)),
-                    image_preprocessing.RandomFlip(mode="horizontal"),
-                    image_preprocessing.RandomZoom(0.2, 0.2),
-                ]
-            )
-            _ = preprocessor(img)
-
-            num_repeats = 5
-            starts = []
-            ends = []
-            for _ in range(num_repeats):
-                ds = tf.data.Dataset.from_tensor_slices(
-                    np.random.random((batch_size, 256, 256, 3))
-                )
-                ds = ds.shuffle(batch_size * 100)
-                ds = ds.batch(batch_size)
-                ds = ds.prefetch(batch_size)
-                starts.append(time.time())
-                count = 0
-                # Benchmarked code begins here.
-                for i in ds:
-                    _ = preprocessor(i)
-                    count += 1
-                # Benchmarked code ends here.
-                ends.append(time.time())
-
-        avg_time = np.mean(np.array(ends) - np.array(starts)) / count
-        name = f"image_preprocessing|batch_{batch_size}"
-        baseline = self.run_dataset_implementation(batch_size)
-        extras = {
-            "dataset implementation baseline": baseline,
-            "delta seconds": (baseline - avg_time),
-            "delta percent": ((baseline - avg_time) / baseline) * 100,
-        }
-        self.report_benchmark(
-            iters=num_repeats, wall_time=avg_time, extras=extras, name=name
-        )
-
-    def benchmark_vocab_size_by_batch(self):
-        for batch in [32, 64, 256]:
-            self.bm_layer_implementation(batch_size=batch)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

tf_keras/src/layers/preprocessing/benchmarks/index_lookup_adapt_benchmark.py

@@ -1,135 +0,0 @@
-# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
-#
-# 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
-#
-#     http://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.
-# ==============================================================================
-"""Benchmark for TF-Keras text vectorization preprocessing layer's adapt method.
-"""
-
-import collections
-import itertools
-import random
-import string
-import time
-
-import numpy as np
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing import index_lookup
-
-tf.compat.v1.enable_v2_behavior()
-
-
-# word_gen creates random sequences of ASCII letters (both lowercase and upper).
-# The number of unique strings is ~2,700.
-def word_gen():
-    for _ in itertools.count(1):
-        yield "".join(random.choice(string.ascii_letters) for i in range(2))
-
-
-def get_top_k(dataset, k):
-    """Python implementation of vocabulary building using a defaultdict."""
-    counts = collections.defaultdict(int)
-    for tensor in dataset:
-        data = tensor.numpy()
-        for element in data:
-            counts[element] += 1
-    sorted_vocab = [
-        k
-        for k, _ in sorted(
-            counts.items(), key=lambda item: item[1], reverse=True
-        )
-    ]
-    if len(sorted_vocab) > k:
-        sorted_vocab = sorted_vocab[:k]
-    return sorted_vocab
-
-
-class BenchmarkAdapt(tf.test.Benchmark):
-    """Benchmark adapt."""
-
-    def run_numpy_implementation(self, num_elements, batch_size, k):
-        """Test the python implementation."""
-        ds = tf.data.Dataset.from_generator(
-            word_gen, tf.string, tf.TensorShape([])
-        )
-        batched_ds = ds.take(num_elements).batch(batch_size)
-        input_t = keras.Input(shape=(), dtype=tf.string)
-        layer = index_lookup.IndexLookup(
-            max_tokens=k,
-            num_oov_indices=0,
-            mask_token=None,
-            oov_token="OOV",
-            dtype=tf.string,
-        )
-        _ = layer(input_t)
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            starts.append(time.time())
-            vocab = get_top_k(batched_ds, k)
-            layer.set_vocabulary(vocab)
-            ends.append(time.time())
-        avg_time = np.mean(np.array(ends) - np.array(starts))
-        return avg_time
-
-    def bm_adapt_implementation(self, num_elements, batch_size, k):
-        """Test the KPL adapt implementation."""
-        ds = tf.data.Dataset.from_generator(
-            word_gen, tf.string, tf.TensorShape([])
-        )
-        batched_ds = ds.take(num_elements).batch(batch_size)
-        input_t = keras.Input(shape=(), dtype=tf.string)
-        layer = index_lookup.IndexLookup(
-            max_tokens=k,
-            num_oov_indices=0,
-            mask_token=None,
-            oov_token="OOV",
-            dtype=tf.string,
-        )
-        _ = layer(input_t)
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            starts.append(time.time())
-            layer.adapt(batched_ds)
-            ends.append(time.time())
-        avg_time = np.mean(np.array(ends) - np.array(starts))
-        name = "index_lookup_adapt|%s_elements|vocab_size_%s|batch_%s" % (
-            num_elements,
-            k,
-            batch_size,
-        )
-        baseline = self.run_numpy_implementation(num_elements, batch_size, k)
-        extras = {
-            "numpy implementation baseline": baseline,
-            "delta seconds": (baseline - avg_time),
-            "delta percent": ((baseline - avg_time) / baseline) * 100,
-        }
-        self.report_benchmark(
-            iters=num_repeats, wall_time=avg_time, extras=extras, name=name
-        )
-
-    def benchmark_vocab_size_by_batch(self):
-        for vocab_size in [100, 1000, 10000, 100000, 1000000]:
-            for batch in [1, 16, 2048]:
-                self.bm_adapt_implementation(
-                    vocab_size, batch, int(vocab_size / 10)
-                )
-
-
-if __name__ == "__main__":
-    tf.test.main()
-