tf-keras-nightly 2.20.0.dev2025062209__py3-none-any.whl → 2.20.0.dev2025082909__py3-none-any.whl

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

@@ -1,87 +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 vocabulary columns from lists with
-varying-length inputs."""
-
-import tensorflow.compat.v2 as tf
-
-import tf_keras.src as keras
-from tf_keras.src.layers.preprocessing import string_lookup
-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, max_length):
-    """Benchmark a variable-length embedding."""
-    # Data and constants.
-    vocab = fc_bm.create_vocabulary(32768)
-    data = fc_bm.create_string_data(
-        max_length, batch_size * NUM_REPEATS, vocab, pct_oov=0.15
-    )
-
-    # TF-Keras implementation
-    model = keras.Sequential()
-    model.add(
-        keras.Input(
-            shape=(max_length,), name="data", ragged=True, dtype=tf.string
-        )
-    )
-    model.add(string_lookup.StringLookup(vocabulary=vocab, mask_token=None))
-
-    # FC implementation
-    fc = tf.feature_column.sequence_categorical_column_with_vocabulary_list(
-        key="data", vocabulary_list=vocab, num_oov_buckets=1
-    )
-
-    # 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"vocab_list|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/discretization_adapt_benchmark.py

@@ -1,109 +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 discretization preprocessing layer's adapt method."""
-
-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 discretization
-
-EPSILON = 0.1
-
-
-def reduce_fn(state, values, epsilon=EPSILON):
-    """tf.data.Dataset-friendly implementation of mean and variance."""
-
-    (state_,) = state
-    summary = discretization.summarize(values, epsilon)
-    if np.sum(state_[:, 0]) == 0:
-        return (summary,)
-    return (discretization.merge_summaries(state_, summary, epsilon),)
-
-
-class BenchmarkAdapt(tf.test.Benchmark):
-    """Benchmark adapt."""
-
-    def run_dataset_implementation(self, num_elements, batch_size):
-        input_t = keras.Input(shape=(1,))
-        layer = discretization.Discretization()
-        _ = layer(input_t)
-
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            ds = tf.data.Dataset.range(num_elements)
-            ds = ds.map(lambda x: tf.expand_dims(tf.cast(x, tf.float32), -1))
-            ds = ds.batch(batch_size)
-
-            starts.append(time.time())
-            # Benchmarked code begins here.
-            state = ds.reduce((np.zeros((1, 2)),), reduce_fn)
-
-            bins = discretization.get_bucket_boundaries(state, 100)
-            layer.set_weights([bins])
-            # Benchmarked code ends here.
-            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):
-        """Test the KPL adapt implementation."""
-        input_t = keras.Input(shape=(1,), dtype=tf.float32)
-        layer = discretization.Discretization()
-        _ = layer(input_t)
-
-        num_repeats = 5
-        starts = []
-        ends = []
-        for _ in range(num_repeats):
-            ds = tf.data.Dataset.range(num_elements)
-            ds = ds.map(lambda x: tf.expand_dims(tf.cast(x, tf.float32), -1))
-            ds = ds.batch(batch_size)
-
-            starts.append(time.time())
-            # Benchmarked code begins here.
-            layer.adapt(ds)
-            # Benchmarked code ends here.
-            ends.append(time.time())
-
-        avg_time = np.mean(np.array(ends) - np.array(starts))
-        name = "discretization_adapt|%s_elements|batch_%s" % (
-            num_elements,
-            batch_size,
-        )
-        baseline = self.run_dataset_implementation(num_elements, batch_size)
-        extras = {
-            "tf.data 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 [64 * 2048]:
-                self.bm_adapt_implementation(vocab_size, batch)
-
-
-if __name__ == "__main__":
-    tf.test.main()
-

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()
-