tf-models-nightly 2.17.0.dev20240606__py2.py3-none-any.whl → 2.17.0.dev20240607__py2.py3-none-any.whl

official/nlp/modeling/layers/block_sparse_attention.py

@@ -0,0 +1,216 @@
+# Copyright 2024 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.
+
+"""Block sparse attention converts query/key/value into blocks and performs diagonal block sparse attention."""
+import collections
+
+import tensorflow as tf, tf_keras
+
+
+class MultiHeadAttention(tf_keras.layers.MultiHeadAttention):
+  """Multi-head block sparse attention layer."""
+
+  def __init__(self, src_block_size=None, tgt_block_size=None, **kwargs):
+    """Initializes the block sparse attention layer.
+
+    Args:
+      src_block_size: The block size of the query. An integer that divides the
+        sequence length into blocks.
+      tgt_block_size: The block size of the key/value. An integer that divides
+        the sequence length into blocks. The number of blocks in the source and
+        target must be the same.
+      **kwargs: Args passed to the base class.
+    """
+    super().__init__(**kwargs)
+    if src_block_size is None or src_block_size <= 0:
+      raise ValueError("src_block_size must be specified.")
+    self._src_block_size = src_block_size
+    self._tgt_block_size = tgt_block_size or self._src_block_size
+
+  def _build_from_signature(self, query, value, key=None):
+    # pytype: disable=attribute-error
+    super()._build_from_signature(query, value, key)
+    # pytype: enable=attribute-error
+    # The following capital letters are used to denote the tensor dimension
+    # parameters:
+    # B = batch size
+    # S = length of the key/value (target)
+    # D = model dimension.
+    # T = length of the query (source)
+    # t = block size of the source.
+    # s = block size of the target.
+    # L = number of blocks in the source/target.
+    # N = number of attention heads
+    # H = dimensions of each attention head.
+    with tf.init_scope():
+      proj_einsum_eqn = "BTD,DNH->BNTH"
+      bias_axes = "NH"
+      qk_output_shape = [
+          self._num_heads,
+          None,
+          self._key_dim,
+      ]
+      v_output_shape = [
+          self._num_heads,
+          None,
+          self._value_dim,
+      ]
+      self._query_dense = tf_keras.layers.EinsumDense(
+          proj_einsum_eqn,
+          output_shape=qk_output_shape,
+          bias_axes=bias_axes if self._use_bias else None,
+          name="query",
+          **self._get_common_kwargs_for_sublayer(),
+      )
+      self._key_dense = tf_keras.layers.EinsumDense(
+          proj_einsum_eqn,
+          output_shape=qk_output_shape,
+          bias_axes=bias_axes if self._use_bias else None,
+          name="key",
+          **self._get_common_kwargs_for_sublayer(),
+      )
+      self._value_dense = tf_keras.layers.EinsumDense(
+          proj_einsum_eqn,
+          output_shape=v_output_shape,
+          bias_axes=bias_axes if self._use_bias else None,
+          name="value",
+          **self._get_common_kwargs_for_sublayer(),
+      )
+      self._dot_product_equation = "BNLsH,BNLtH->BNLts"
+      self._combine_equation = "BNLts,BNLsH->BNLtH"
+      if self._output_shape:
+        if not isinstance(self._output_shape, collections.abc.Sized):
+          output_shape = [self._output_shape]
+        else:
+          output_shape = self._output_shape
+      else:
+        output_shape = [self._query_shape[-1]]
+      output_shape = [None] + output_shape
+      self._output_dense = tf_keras.layers.EinsumDense(
+          "BNTH,DNH->BTD",
+          output_shape=output_shape,
+          bias_axes="D" if self._use_bias else None,
+          name="attention_output",
+          **self._get_common_kwargs_for_sublayer(),
+      )
+
+  def _block_diagonal_mask(self, attention_mask, dtype=None):
+    """Converts the attention mask to block diagonal."""
+    # Uses the same key mask for the entire query sequence since softmax
+    # is applied only on the key axis.
+    attention_mask = tf.cast(attention_mask[:, 0, :], dtype=dtype)
+    tgt_num_blocks = self._key_shape[-2] // self._tgt_block_size
+    attention_mask = tf.reshape(
+        attention_mask,
+        [
+            -1,
+            tgt_num_blocks,
+            self._tgt_block_size,
+        ],
+    )
+    return tf.einsum("BLQ,BLK->BLQK", attention_mask, attention_mask)
+
+  def _masked_softmax(self, attention_scores, attention_mask=None):
+    # Normalize the attention scores to probabilities.
+    # `attention_scores` = [B, N, L, T, S]
+    if attention_mask is not None:
+      # `attention_mask` = [B, 1, L, T, S]
+      attention_mask = tf.expand_dims(attention_mask, axis=1)
+    return self._softmax(attention_scores, attention_mask)
+
+  def _compute_attention(
+      self, query, key, value, attention_mask=None, training=None
+  ):
+    # src_num_blocks and tgt_num_blocks are the number of blocks in the source
+    # and target. Care should be taken to ensure that the number of blocks in
+    # the source and target are the same.
+    if self._query_shape[-2] % self._src_block_size != 0:
+      raise ValueError(
+          "query_shape[-2] must be divisible by src_block_size."
+      )
+    if self._key_shape[-2] % self._tgt_block_size != 0:
+      raise ValueError(
+          "key_shape[-2] must be divisible by tgt_block_size."
+      )
+    src_num_blocks = self._query_shape[-2] // self._src_block_size
+    tgt_num_blocks = self._key_shape[-2] // self._tgt_block_size
+
+    if src_num_blocks != tgt_num_blocks:
+      raise ValueError(
+          "src_num_blocks must be equal to tgt_num_blocks."
+      )
+    # Convert the query/key/value into blocks to perform block diagonal
+    # attention.
+    query_blocks = tf.reshape(query, [
+        -1,
+        self._num_heads,
+        src_num_blocks,
+        self._src_block_size,
+        self._key_dim,
+    ])
+    key_blocks = tf.reshape(key, [
+        -1,
+        self._num_heads,
+        tgt_num_blocks,
+        self._tgt_block_size,
+        self._key_dim,
+    ])
+    value_blocks = tf.reshape(value, [
+        -1,
+        self._num_heads,
+        tgt_num_blocks,
+        self._tgt_block_size,
+        self._value_dim,
+    ])
+    if attention_mask is not None:
+      attention_mask = self._block_diagonal_mask(attention_mask, key.dtype)
+    # pytype: disable=attribute-error
+    attention_output, attention_scores = super()._compute_attention(
+        query_blocks,
+        key_blocks,
+        value_blocks,
+        attention_mask=attention_mask,
+        training=training,
+    )
+    # pytype: enable=attribute-error
+    # Reshape the attention output to the original shape.
+    attention_output = tf.reshape(attention_output, [
+        -1,
+        self._num_heads,
+        self._query_shape[1],
+        self._value_dim,
+    ])
+    return attention_output, attention_scores
+
+  def call(
+      self,
+      query,
+      value,
+      key=None,
+      attention_mask=None,
+      return_attention_scores=False,
+      training=None,
+      use_causal_mask=False,
+  ):
+    if use_causal_mask:
+      raise ValueError("use_causal_mask is not supported.")
+    return super().call(
+        query,
+        value,
+        key=key,
+        attention_mask=attention_mask,
+        return_attention_scores=return_attention_scores,
+        training=training,
+        use_causal_mask=use_causal_mask,
+    )

official/nlp/modeling/layers/block_sparse_attention_test.py

@@ -0,0 +1,303 @@
+# Copyright 2024 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.
+
+"""Tests for block sparse attention layer."""
+
+from absl.testing import parameterized
+import numpy as np
+import tensorflow as tf, tf_keras
+
+from official.nlp.modeling.layers import block_sparse_attention
+
+
+class BlockSparseAttentionTest(tf.test.TestCase, parameterized.TestCase):
+
+  @parameterized.named_parameters(
+      ("key_value_same_proj", None, None, [40, 80]),
+      ("key_value_different_proj", 32, 60, [40, 60]),
+  )
+  def test_non_masked_attention(self, value_dim, output_shape, output_dims):
+    """Test that the attention layer can be created without a mask tensor."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=12,
+        key_dim=64,
+        value_dim=value_dim,
+        output_shape=output_shape,
+        src_block_size=10,
+        tgt_block_size=5,
+    )
+    # Create a 3-dimensional input (the first dimension is implicit).
+    query = tf_keras.Input(shape=(40, 80))
+    value = tf_keras.Input(shape=(20, 80))
+    output = test_layer(query=query, value=value)
+    self.assertEqual(output.shape.as_list(), [None] + output_dims)
+
+  def test_non_masked_self_attention(self):
+    """Test with one input (self-attenntion) and no mask tensor."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=12, key_dim=64, src_block_size=10, tgt_block_size=10
+    )
+    # Create a 3-dimensional input (the first dimension is implicit).
+    query = tf_keras.Input(shape=(40, 80))
+    output = test_layer(query, query)
+    self.assertEqual(output.shape.as_list(), [None, 40, 80])
+
+  @parameterized.named_parameters(("with_bias", True), ("no_bias", False))
+  def test_masked_attention(self, use_bias):
+    """Test with a mask tensor."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=4, key_dim=2, use_bias=use_bias, src_block_size=2,
+        tgt_block_size=1,
+    )
+    # Create a 3-dimensional input (the first dimension is implicit).
+    batch_size = 3
+    query = tf_keras.Input(shape=(4, 8))
+    value = tf_keras.Input(shape=(2, 8))
+    mask_tensor = tf_keras.Input(shape=(4, 2))
+    output = test_layer(query=query, value=value, attention_mask=mask_tensor)
+
+    # Create a model containing the test layer.
+    model = tf_keras.Model([query, value, mask_tensor], output)
+
+    # Generate data for the input (non-mask) tensors.
+    from_data = 10 * np.random.random_sample((batch_size, 4, 8))
+    to_data = 10 * np.random.random_sample((batch_size, 2, 8))
+
+    # Invoke the data with a random set of mask data. This should mask at
+    # least one element.
+    mask_data = np.random.randint(2, size=(batch_size, 4, 2))
+    masked_output_data = model.predict([from_data, to_data, mask_data])
+
+    # Invoke the same data, but with a null mask (where no elements are
+    # masked).
+    null_mask_data = np.ones((batch_size, 4, 2))
+    unmasked_output_data = model.predict([from_data, to_data, null_mask_data])
+
+    # Because one data is masked and one is not, the outputs should not be
+    # the same.
+    self.assertNotAllClose(masked_output_data, unmasked_output_data)
+
+    # Tests the layer with three inputs: Q, K, V.
+    key = tf_keras.Input(shape=(2, 8))
+    output = test_layer(
+        query, value=value, key=key, attention_mask=mask_tensor
+    )
+    model = tf_keras.Model([query, value, key, mask_tensor], output)
+
+    masked_output_data = model.predict(
+        [from_data, to_data, to_data, mask_data]
+    )
+    unmasked_output_data = model.predict(
+        [from_data, to_data, to_data, null_mask_data]
+    )
+    # Because one data is masked and one is not, the outputs should not be
+    # the same.
+    self.assertNotAllClose(masked_output_data, unmasked_output_data)
+
+    if use_bias:
+      self.assertLen(test_layer._query_dense.trainable_variables, 2)
+      self.assertLen(test_layer._output_dense.trainable_variables, 2)
+    else:
+      self.assertLen(test_layer._query_dense.trainable_variables, 1)
+      self.assertLen(test_layer._output_dense.trainable_variables, 1)
+
+  def test_masked_attention_with_scores(self):
+    """Test with a mask tensor."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=4, key_dim=2, src_block_size=2, tgt_block_size=1,
+    )
+    # Create a 3-dimensional input (the first dimension is implicit).
+    batch_size = 3
+    query = tf_keras.Input(shape=(4, 8))
+    value = tf_keras.Input(shape=(2, 8))
+    mask_tensor = tf_keras.Input(shape=(4, 2))
+    output = test_layer(query=query, value=value, attention_mask=mask_tensor)
+
+    # Create a model containing the test layer.
+    model = tf_keras.Model([query, value, mask_tensor], output)
+
+    # Generate data for the input (non-mask) tensors.
+    from_data = 10 * np.random.random_sample((batch_size, 4, 8))
+    to_data = 10 * np.random.random_sample((batch_size, 2, 8))
+
+    # Invoke the data with a random set of mask data. This should mask at
+    # least one element.
+    mask_data = np.random.randint(2, size=(batch_size, 4, 2))
+    masked_output_data = model.predict([from_data, to_data, mask_data])
+
+    # Invoke the same data, but with a null mask (where no elements are
+    # masked).
+    null_mask_data = np.ones((batch_size, 4, 2))
+    unmasked_output_data = model.predict([from_data, to_data, null_mask_data])
+
+    # Because one data is masked and one is not, the outputs should not be
+    # the same.
+    self.assertNotAllClose(masked_output_data, unmasked_output_data)
+
+    # Create a model containing attention scores.
+    output, scores = test_layer(
+        query=query,
+        value=value,
+        attention_mask=mask_tensor,
+        return_attention_scores=True,
+    )
+    model = tf_keras.Model([query, value, mask_tensor], [output, scores])
+    masked_output_data_score, masked_score = model.predict(
+        [from_data, to_data, mask_data]
+    )
+    unmasked_output_data_score, unmasked_score = model.predict(
+        [from_data, to_data, null_mask_data]
+    )
+    self.assertNotAllClose(masked_output_data_score, unmasked_output_data_score)
+    self.assertAllClose(masked_output_data, masked_output_data_score)
+    self.assertAllClose(unmasked_output_data, unmasked_output_data_score)
+    self.assertNotAllClose(masked_score, unmasked_score)
+
+  def test_initializer(self):
+    """Test with a specified initializer."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=12,
+        key_dim=64,
+        src_block_size=10,
+        kernel_initializer=tf_keras.initializers.TruncatedNormal(stddev=0.02),
+    )
+    # Create a 3-dimensional input (the first dimension is implicit).
+    query = tf_keras.Input(shape=(40, 80))
+    output = test_layer(query, query)
+    self.assertEqual(output.shape.as_list(), [None, 40, 80])
+
+    # Make sure the sub layers have different kernel init value, and not
+    # reusing the initializers.
+    self.assertNotAllClose(
+        tf_keras.backend.eval(test_layer._query_dense.kernel),
+        tf_keras.backend.eval(test_layer._key_dense.kernel),
+    )
+    self.assertNotAllClose(
+        tf_keras.backend.eval(test_layer._query_dense.kernel),
+        tf_keras.backend.eval(test_layer._value_dense.kernel),
+    )
+    self.assertNotAllClose(
+        tf_keras.backend.eval(test_layer._query_dense.kernel),
+        tf_keras.backend.eval(test_layer._output_dense.kernel),
+    )
+
+  @parameterized.named_parameters(
+      ("bfloat16", tf.bfloat16),
+      ("float16", tf.float16),
+      ("float32", tf.float32),
+      ("float64", tf.float64),
+  )
+  def test_sublayer_dtypes(self, dtype):
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=12, key_dim=64, src_block_size=10, dtype=dtype
+    )
+
+    query = tf_keras.Input(shape=(40, 80), dtype=dtype)
+    # Build the layer
+    test_layer(query=query, value=query)
+
+    self.assertEqual(test_layer._query_dense.dtype, dtype)
+    self.assertEqual(test_layer._key_dense.dtype, dtype)
+    self.assertEqual(test_layer._value_dense.dtype, dtype)
+    self.assertEqual(test_layer._output_dense.dtype, dtype)
+
+  def test_dropout(self):
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=2, key_dim=2, dropout=0.5, src_block_size=2, tgt_block_size=1,
+    )
+
+    # Generate data for the input (non-mask) tensors.
+    from_data = tf_keras.backend.ones(shape=(32, 4, 8))
+    to_data = tf_keras.backend.ones(shape=(32, 2, 8))
+    train_out = test_layer(from_data, to_data, None, None, None, True)
+    test_out = test_layer(from_data, to_data, None, None, None, False)
+
+    # Output should be close when not in training mode,
+    # and should not be close when enabling dropout in training mode.
+    self.assertNotAllClose(
+        tf_keras.backend.eval(train_out), tf_keras.backend.eval(test_out)
+    )
+
+  def test_query_mask_progagation(self):
+    """Test automatic propagation of the query's mask."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=2,
+        key_dim=2,
+        src_block_size=2,
+        tgt_block_size=1,
+    )
+    self.assertTrue(test_layer.supports_masking)
+    query = tf.constant(
+        [[1, 2, 3, 0, 0, 0], [3, 3, 1, 1, 2, 0], [1, 1, 0, 0, 0, 0]]
+    )
+    masked_query = tf_keras.layers.Embedding(4, 8, mask_zero=True)(query)
+    value = tf.random.normal((3, 3, 8))
+    output = test_layer(query=masked_query, value=value)
+    self.assertTrue(hasattr(output, "_keras_mask"))
+    self.assertAllEqual(masked_query._keras_mask, output._keras_mask)
+
+  def test_value_mask(self):
+    """Test that the value mask is taken into account."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=2,
+        key_dim=2,
+        src_block_size=2,
+        tgt_block_size=1,
+    )
+    query = tf.constant(
+        [[1, 2, 3, 0, 0, 0], [3, 3, 1, 1, 2, 0], [1, 1, 0, 0, 0, 0]]
+    )
+    masked_query = tf_keras.layers.Embedding(4, 8, mask_zero=True)(query)
+    value = tf.constant([[5, 4, 0], [3, 0, 0], [2, 1, 1]])
+    masked_value = tf_keras.layers.Embedding(6, 8, mask_zero=True)(value)
+    output = test_layer(
+        query=masked_query,
+        value=masked_value,
+    )
+    mask = tf.constant(
+        [[[True, True, False]] * 3 + [[False, False, False]] * 2]
+        + [[[True, False, False]] * 5]
+        + [[[True, True, True]] + [[False, False, False]] * 4]
+    )
+    del masked_query._keras_mask
+    del masked_value._keras_mask
+    output_with_manual_mask = test_layer(
+        query=masked_query, value=masked_value, attention_mask=mask
+    )
+    self.assertAllClose(output, output_with_manual_mask)
+
+  def test_masks_are_cast_to_bool(self):
+    """Test that the implicit and explicit masks are cast to bool."""
+    test_layer = block_sparse_attention.MultiHeadAttention(
+        num_heads=2, key_dim=2, src_block_size=2, tgt_block_size=1,
+    )
+    query = np.array(
+        [[1, 2, 3, 0, 0, 0], [3, 3, 1, 1, 2, 0], [1, 1, 0, 0, 0, 0]]
+    )
+    masked_query = tf_keras.layers.Embedding(4, 8, mask_zero=True)(query)
+    masked_query._keras_mask = tf.cast(masked_query._keras_mask, tf.float32)
+    value = np.array([[5, 4, 0], [3, 0, 0], [2, 1, 1]])
+    masked_value = tf_keras.layers.Embedding(6, 8, mask_zero=True)(value)
+    masked_value._keras_mask = tf.cast(masked_value._keras_mask, tf.float32)
+    float_mask = tf.constant([[[1.0]]])
+    # if all works well, the following should not raise any exception:
+    _ = test_layer(
+        query=masked_query,
+        value=masked_value,
+        attention_mask=float_mask,
+    )
+
+
+if __name__ == "__main__":
+  tf.test.main()

{tf_models_nightly-2.17.0.dev20240606.dist-info → tf_models_nightly-2.17.0.dev20240607.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tf-models-nightly
-Version: 2.17.0.dev20240606
+Version: 2.17.0.dev20240607
 Summary: TensorFlow Official Models
 Home-page: https://github.com/tensorflow/models
 Author: Google Inc.

{tf_models_nightly-2.17.0.dev20240606.dist-info → tf_models_nightly-2.17.0.dev20240607.dist-info}/RECORD

@@ -305,6 +305,8 @@ official/nlp/modeling/layers/bigbird_attention.py,sha256=dzutgRoQt2DFsYMpMILv_QF
 official/nlp/modeling/layers/bigbird_attention_test.py,sha256=cBYwK5k1rnykZ0gif-n7VaByLIoElA-N0_svCRKASoU,2206
 official/nlp/modeling/layers/block_diag_feedforward.py,sha256=FDEt-J_QjOxwar3eT5yjMs4hR41Ppke1zj7iswsZR4M,7243
 official/nlp/modeling/layers/block_diag_feedforward_test.py,sha256=wcg8In6FIOCxcKqe5rucftjJ_kUWTi9Ei7eEmlVCYpE,4181
+official/nlp/modeling/layers/block_sparse_attention.py,sha256=Vjy0JULOb9u6-EzD460kXCotsibqyD29imlmrb7aVSY,7580
+official/nlp/modeling/layers/block_sparse_attention_test.py,sha256=YF2_-I27INUFtu-WP7s7C1kpYmsobNIGOWM1iUvSD5Y,12041
 official/nlp/modeling/layers/cls_head.py,sha256=0X_gdjnAt6TZVrH_xkDcQCpwLuVz5Pb7d04wEVN_Kn8,16208
 official/nlp/modeling/layers/cls_head_test.py,sha256=01oMmiuyp1lDEXBYa9r3krn6BtH-QuSedGOca9LViEc,8888
 official/nlp/modeling/layers/factorized_embedding.py,sha256=4oFRYJbpoaSxqv8hTWY2JPGPllp-zhniz99IyRtlzV8,2902
@@ -1210,9 +1212,9 @@ tensorflow_models/tensorflow_models_test.py,sha256=nc6A9K53OGqF25xN5St8EiWvdVbda
 tensorflow_models/nlp/__init__.py,sha256=4tA5Pf4qaFwT-fIFOpX7x7FHJpnyJT-5UgOeFYTyMlc,807
 tensorflow_models/uplift/__init__.py,sha256=mqfa55gweOdpKoaQyid4A_4u7xw__FcQeSIF0k_pYmI,999
 tensorflow_models/vision/__init__.py,sha256=zBorY_v5xva1uI-qxhZO3Qh-Dii-Suq6wEYh6hKHDfc,833
-tf_models_nightly-2.17.0.dev20240606.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240606.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240606.dist-info/METADATA,sha256=lAg2jWgOJTr2BqPQAYugSYGcJOYFHeKst5MSY8bdGog,1432
-tf_models_nightly-2.17.0.dev20240606.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240606.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240606.dist-info/RECORD,,
+tf_models_nightly-2.17.0.dev20240607.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.17.0.dev20240607.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.17.0.dev20240607.dist-info/METADATA,sha256=1SHRPPXdMY0dawg-D-jqd8Qx0zRUtpYkN823Msxf_2s,1432
+tf_models_nightly-2.17.0.dev20240607.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.17.0.dev20240607.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.17.0.dev20240607.dist-info/RECORD,,