tf-models-nightly 2.17.0.dev20240412__py2.py3-none-any.whl → 2.17.0.dev20240414__py2.py3-none-any.whl

official/recommendation/uplift/metrics/loss_metric.py

@@ -183,6 +183,9 @@ class LossMetric(tf_keras.metrics.Metric):
   def result(self) -> tf.Tensor | dict[str, tf.Tensor]:
     return self._loss.result()
 
+  def reset_state(self):
+    self._loss.reset_state()
+
   def get_config(self) -> dict[str, Any]:
     config = super().get_config()
     config["loss_fn"] = tf_keras.utils.serialize_keras_object(self._loss_fn)

official/recommendation/uplift/metrics/poisson_metrics.py

@@ -0,0 +1,123 @@
+# 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.
+
+"""Poisson regression metrics."""
+
+from __future__ import annotations
+
+from typing import Any
+
+import tensorflow as tf, tf_keras
+
+from official.recommendation.uplift import types
+from official.recommendation.uplift.metrics import loss_metric
+
+
+@tf_keras.utils.register_keras_serializable(package="Uplift")
+class LogLoss(loss_metric.LossMetric):
+  """Computes the (weighted) poisson log loss sliced by treatment group.
+
+  Given labels `y` and the model's predictions `x`, the loss is computed as:
+  `loss = x - y * log(x) + [y * log(y) - y + 0.5 * log(2 * pi * y)]`
+
+  Note that from a numerical perspective it is preferred to compute the loss
+  from the model's logits as opposed to directly using its predictions, where
+  `logits = log(x) = log(prediction)`. In this case the loss is computed as:
+  `loss = exp(logits) - y * logits + [y * log(y) - y + 0.5 * log(2 * pi * y)]`
+
+  Example standalone usage:
+
+  >>> poisson_loss = poisson_metrics.LogLoss()
+  >>> y_true = tf.constant([[1.0], [0.0]])
+  >>> y_pred = types.TwoTowerTrainingOutputs(
+      true_logits=tf.constant([[1.0], [0.0]]),
+      is_treatment=tf.constant([[1], [0]]),
+  )
+  >>> poisson_loss(y_true=y_true, y_pred=y_pred)
+  {
+      "poisson_log_loss/treatment": 1.7182817  # exp(1) - 1 * 1
+      "poisson_log_loss/control": 1.0  # exp(0) - 0 * 0
+      "poisson_log_loss": 1.3591409  # (1.7182817 + 1.0) / 2
+  }
+
+  Example usage with the `model.compile()` API:
+
+  >>> model.compile(
+  ...     optimizer="sgd",
+  ...     loss=TrueLogitsLoss(tf.nn.log_poisson_loss),
+  ...     metrics=[poisson_metrics.LogLoss()]
+  ... )
+  """
+
+  def __init__(
+      self,
+      from_logits: bool = True,
+      compute_full_loss: bool = False,
+      slice_by_treatment: bool = True,
+      name: str = "poisson_log_loss",
+      dtype: tf.DType = tf.float32,
+  ):
+    """Initializes the instance.
+
+    Args:
+      from_logits: When `y_pred` is of type `tf.Tensor`, specifies whether
+        `y_pred` represents the model's logits or predictions. Otherwise, when
+        `y_pred` is of type `TwoTowerTrainingOutputs`, set this to `True` in
+        order to compute the loss using the true logits.
+      compute_full_loss: Specifies whether the full log loss will be computed.
+        If `True`, the expression `[y_true * log(y_true) - y_true + 0.5 * log(2
+        * pi * y_true)]` will be added to the loss, otherwise the loss will be
+        computed solely by the expression `[y_pred - y_true * log(y_pred)]`.
+      slice_by_treatment: Specifies whether the loss should be sliced by the
+        treatment indicator tensor. If `True`, the metric's result will return
+        the loss values sliced by the treatment group. Note that this can only
+        be set to `True` when `y_pred` is of type `TwoTowerTrainingOutputs`.
+      name: Optional name for the instance.
+      dtype: Optional data type for the instance.
+    """
+    super().__init__(
+        loss_fn=tf.nn.log_poisson_loss,
+        from_logits=from_logits,
+        compute_full_loss=compute_full_loss,
+        slice_by_treatment=slice_by_treatment,
+        name=name,
+        dtype=dtype,
+    )
+
+  def update_state(
+      self,
+      y_true: tf.Tensor,
+      y_pred: types.TwoTowerTrainingOutputs | tf.Tensor,
+      sample_weight: tf.Tensor | None = None,
+  ):
+    if not self._from_logits:
+      if isinstance(y_pred, types.TwoTowerTrainingOutputs):
+        raise ValueError(
+            "`from_logits` must be set to `True` when `y_pred` is of type"
+            " TwoTowerTrainingOutputs. Note that the true logits and true"
+            " predictions are assumed to be linked to each other through the"
+            " log link function: `true_logits = tf.math.log(true_predictions)."
+        )
+      y_pred = tf.math.log(y_pred)
+
+    super().update_state(y_true, y_pred, sample_weight)
+
+  def get_config(self) -> dict[str, Any]:
+    config = super().get_config()
+    del config["loss_fn"]
+    return config
+
+  @classmethod
+  def from_config(cls, config: dict[str, Any]) -> LogLoss:
+    return cls(**config)

official/recommendation/uplift/metrics/poisson_metrics_test.py

@@ -0,0 +1,181 @@
+# 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 poisson regression metrics."""
+
+from absl.testing import parameterized
+import tensorflow as tf, tf_keras
+
+from official.recommendation.uplift import keras_test_case
+from official.recommendation.uplift import types
+from official.recommendation.uplift.metrics import poisson_metrics
+
+
+def _get_two_tower_outputs(
+    true_logits: tf.Tensor, is_treatment: tf.Tensor
+) -> types.TwoTowerTrainingOutputs:
+  # Only the true_logits and is_treatment tensors are needed for testing.
+  return types.TwoTowerTrainingOutputs(
+      shared_embedding=tf.ones_like(is_treatment),
+      control_predictions=tf.ones_like(is_treatment),
+      treatment_predictions=tf.ones_like(is_treatment),
+      uplift=tf.ones_like(is_treatment),
+      control_logits=tf.ones_like(is_treatment),
+      treatment_logits=tf.ones_like(is_treatment),
+      true_logits=true_logits,
+      true_predictions=tf.ones_like(is_treatment),
+      is_treatment=is_treatment,
+  )
+
+
+class LogLossTest(keras_test_case.KerasTestCase, parameterized.TestCase):
+
+  @parameterized.named_parameters(
+      {
+          "testcase_name": "two_tower_outputs_not_sliced",
+          "from_logits": True,
+          "compute_full_loss": False,
+          "slice_by_treatment": False,
+          "y_true": tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              true_logits=tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+              is_treatment=tf.constant([[1], [0], [1], [0]]),
+          ),
+          "expected_loss": tf.reduce_mean(
+              tf.nn.log_poisson_loss(
+                  tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+                  tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+              )
+          ),
+      },
+      {
+          "testcase_name": "two_tower_outputs_sliced",
+          "from_logits": True,
+          "compute_full_loss": False,
+          "slice_by_treatment": True,
+          "y_true": tf.constant([[1], [0]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              true_logits=tf.constant([[1], [0]], dtype=tf.float32),
+              is_treatment=tf.constant([[1], [0]]),
+          ),
+          "expected_loss": {
+              "poisson_log_loss/treatment": (
+                  tf.math.exp(1.0) - 1  # exp(1) - 1 * 1
+              ),
+              "poisson_log_loss/control": 1.0,  # exp(0) - 0 * 0
+              "poisson_log_loss": ((tf.math.exp(1.0) - 1) + 1) / 2,
+          },
+      },
+      {
+          "testcase_name": "tensor_outputs_from_logits",
+          "from_logits": True,
+          "compute_full_loss": False,
+          "slice_by_treatment": False,
+          "y_true": tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+          "expected_loss": tf.reduce_mean(
+              tf.nn.log_poisson_loss(
+                  tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+                  tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+              )
+          ),
+      },
+      {
+          "testcase_name": "tensor_outputs_from_logits_full_loss",
+          "from_logits": True,
+          "compute_full_loss": True,
+          "slice_by_treatment": False,
+          "y_true": tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+          "expected_loss": tf.reduce_mean(
+              tf.nn.log_poisson_loss(
+                  tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+                  tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+                  compute_full_loss=True,
+              )
+          ),
+      },
+      {
+          "testcase_name": "tensor_outputs_from_predictions",
+          "from_logits": False,
+          "compute_full_loss": False,
+          "slice_by_treatment": False,
+          "y_true": tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+          "expected_loss": tf.reduce_mean(
+              tf.nn.log_poisson_loss(
+                  tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+                  tf.math.log(
+                      tf.constant([[1], [2], [3], [4]], dtype=tf.float32)
+                  ),
+              )
+          ),
+      },
+      {
+          "testcase_name": "tensor_outputs_from_predictions_full_loss",
+          "from_logits": False,
+          "compute_full_loss": True,
+          "slice_by_treatment": False,
+          "y_true": tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+          "expected_loss": tf.reduce_mean(
+              tf.nn.log_poisson_loss(
+                  tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+                  tf.math.log(
+                      tf.constant([[1], [2], [3], [4]], dtype=tf.float32)
+                  ),
+                  compute_full_loss=True,
+              )
+          ),
+      },
+  )
+  def test_metric_computes_correct_loss(
+      self,
+      from_logits: bool,
+      compute_full_loss: bool,
+      slice_by_treatment: bool,
+      y_true: tf.Tensor,
+      y_pred: tf.Tensor,
+      expected_loss: tf.Tensor,
+  ):
+    metric = poisson_metrics.LogLoss(
+        from_logits=from_logits,
+        compute_full_loss=compute_full_loss,
+        slice_by_treatment=slice_by_treatment,
+    )
+    metric.update_state(y_true, y_pred)
+    self.assertAllClose(expected_loss, metric.result())
+
+  @parameterized.product(
+      from_logits=(True, False),
+      compute_full_loss=(True, False),
+  )
+  def test_metric_is_configurable(
+      self, from_logits: bool, compute_full_loss: bool
+  ):
+    metric = poisson_metrics.LogLoss(
+        from_logits=from_logits,
+        compute_full_loss=compute_full_loss,
+        slice_by_treatment=False,
+    )
+    self.assertLayerConfigurable(
+        layer=metric,
+        y_true=tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+        y_pred=tf.constant([[1], [2], [3], [4]], dtype=tf.float32),
+        serializable=True,
+    )
+
+
+if __name__ == "__main__":
+  tf.test.main()

official/recommendation/uplift/metrics/sliced_metric.py

@@ -193,6 +193,11 @@ class SlicedMetric(tf_keras.metrics.Metric):
         f"{metric_result}."
     )
 
+  def reset_state(self):
+    self._metric.reset_state()
+    for metric in self._sliced_metrics:
+      metric.reset_state()
+
   def get_config(self):
     return {
         "name": self.name,

official/recommendation/uplift/metrics/sliced_metric_test.py

@@ -315,6 +315,33 @@ class SlicedMetricTest(keras_test_case.KerasTestCase, parameterized.TestCase):
     }
     self.assertDictEqual(expected_result, metric.result())
 
+  def test_reset_state(self):
+    metric = sliced_metric.SlicedMetric(
+        metric=tf_keras.metrics.AUC(curve="PR", from_logits=False, name="auc"),
+        slicing_spec={"control": False, "treatment": True},
+    )
+
+    expected_initial_result = {
+        "auc": 0.0,
+        "auc/control": 0.0,
+        "auc/treatment": 0.0,
+    }
+    self.assertAllClose(expected_initial_result, metric.result())
+
+    metric.update_state(
+        tf.constant([[0], [0], [1], [1]]),  # y_true
+        tf.constant([[0.2], [0.6], [0.3], [0.7]]),  # y_pred
+        slicing_feature=tf.constant([[True], [False], [True], [False]]),
+    )
+
+    result = metric.result()
+    self.assertGreater(result["auc"], 0.0)
+    self.assertGreater(result["auc/control"], 0.0)
+    self.assertGreater(result["auc/treatment"], 0.0)
+
+    metric.reset_state()
+    self.assertAllClose(expected_initial_result, metric.result())
+
   def test_metric_config(self):
     metric = sliced_metric.SlicedMetric(
         tf_keras.metrics.SparseTopKCategoricalAccuracy(k=2, name="accuracy@2"),

official/recommendation/uplift/models/two_tower_uplift_model_test.py

@@ -21,6 +21,7 @@ from official.recommendation.uplift import keras_test_case
 from official.recommendation.uplift import keys
 from official.recommendation.uplift.layers.uplift_networks import two_tower_uplift_network
 from official.recommendation.uplift.losses import true_logits_loss
+from official.recommendation.uplift.metrics import loss_metric
 from official.recommendation.uplift.models import two_tower_uplift_model
 
 
@@ -127,6 +128,53 @@ class TwoTowerUpliftModelTest(
     }
     self.assertAllClose(expected_predictions, model.predict(dataset))
 
+  def test_classification_model_trains(self):
+    tf_keras.utils.set_random_seed(1)
+
+    # Create binary classifier uplift model.
+    uplift_network = self._get_uplift_network(
+        control_feature_encoder=None, control_input_combiner=None
+    )
+    model = two_tower_uplift_model.TwoTowerUpliftModel(
+        treatment_indicator_feature_name="is_treatment",
+        uplift_network=uplift_network,
+        inverse_link_fn=tf.math.sigmoid,
+    )
+    model.compile(
+        optimizer=tf_keras.optimizers.SGD(0.1),
+        loss=true_logits_loss.TrueLogitsLoss(
+            loss_fn=tf_keras.losses.binary_crossentropy, from_logits=True
+        ),
+        metrics=[
+            loss_metric.LossMetric(
+                tf_keras.metrics.AUC(curve="PR", from_logits=True, name="aucpr")
+            ),
+        ],
+    )
+
+    # Create toy classification dataset.
+    treatment = tf.constant([[1], [1], [0], [1], [1], [1], [0], [1], [0], [1]])
+    y = treatment
+    dataset = tf.data.Dataset.from_tensor_slices((
+        {
+            "shared_feature": np.random.normal(size=(10, 1)),
+            "treatment_feature": np.random.normal(size=(10, 1)),
+            "is_treatment": treatment,
+        },
+        y,
+    )).batch(5)
+
+    # Test model training.
+    history = model.fit(dataset, epochs=100)
+    self.assertIn("loss", history.history)
+    self.assertLen(history.history["loss"], 100)
+    self.assertBetween(
+        history.history["loss"][-1], 0.0, history.history["loss"][0]
+    )
+    self.assertIn("aucpr", history.history)
+    self.assertLess(history.history["aucpr"][0], 1.0)
+    self.assertEqual(history.history["aucpr"][-1], 1.0)
+
   @parameterized.named_parameters(
       {
           "testcase_name": "identity",

{tf_models_nightly-2.17.0.dev20240412.dist-info → tf_models_nightly-2.17.0.dev20240414.dist-info}/METADATA

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

{tf_models_nightly-2.17.0.dev20240412.dist-info → tf_models_nightly-2.17.0.dev20240414.dist-info}/RECORD

@@ -912,11 +912,13 @@ official/recommendation/uplift/metrics/label_mean.py,sha256=ECaes7FZmsksnwySn7jf
 official/recommendation/uplift/metrics/label_mean_test.py,sha256=b_d3lNlpkDm2xKLUkxfiXeQg7pjL8HNx7y9NaYarpV0,7083
 official/recommendation/uplift/metrics/label_variance.py,sha256=9DCl42BJkehxfWD3pSbZnRNvwfhVM6VyHwivGdaU72s,3610
 official/recommendation/uplift/metrics/label_variance_test.py,sha256=k0mdEU1WU53-HIEO5HGtfp1MleifD-h4bZNKtTvM3Ws,7681
-official/recommendation/uplift/metrics/loss_metric.py,sha256=owN7A98TCc_UhOURvGfccaoVGOthdHdx1_fawEUGnmw,7289
+official/recommendation/uplift/metrics/loss_metric.py,sha256=gYZdnTsuL_2q1FZuPip-DaWxt_Q-02YYaePyMBVNx7w,7344
 official/recommendation/uplift/metrics/loss_metric_test.py,sha256=48rQG8bKFdy0xBFjoOLXKRUlYpCEyAzSmPOFoF7FX94,16021
 official/recommendation/uplift/metrics/metric_configs.py,sha256=Z-r79orE4EycQ5TJ7xdI5LhjOHT3wzChYyDxcxGqLXk,1670
-official/recommendation/uplift/metrics/sliced_metric.py,sha256=O2I2apZK6IfOQK9Q_mgSiTUCnGokczp4e14zrrYNeRU,8564
-official/recommendation/uplift/metrics/sliced_metric_test.py,sha256=dhY41X8lqT_WW04XLjyjDerZwujEBGeTXtxf4NkYThw,11359
+official/recommendation/uplift/metrics/poisson_metrics.py,sha256=LJnovpST0H9kFGu-ziDstWOVlAYARLo9oPLDTjzrdu4,4623
+official/recommendation/uplift/metrics/poisson_metrics_test.py,sha256=Kd8CuQeEBlxRklA-7mGKHcUD0CyskE1S3cJqk6mEvv4,6756
+official/recommendation/uplift/metrics/sliced_metric.py,sha256=uhvzudOWtMNKZ0avwGhX-37UELR9Cq9b4C0g8erBkXw,8688
+official/recommendation/uplift/metrics/sliced_metric_test.py,sha256=bhVGyI1tOkFkVOtruJo3p6XopDFyG1JW5qdZm9-RqeU,12248
 official/recommendation/uplift/metrics/treatment_fraction.py,sha256=WHrKfsN42xU7S-pK99xEVpVtd3zLD7UidLT1K8vgIn4,2757
 official/recommendation/uplift/metrics/treatment_fraction_test.py,sha256=LtFljDdz9yfH1GNDMo8OcdS4yhsez5WyHsthH3qJf3s,5430
 official/recommendation/uplift/metrics/treatment_sliced_metric.py,sha256=S0ZSoOHcjeWDWiEZlRnFHtRkOzizvrfmsFwbYP0Z0rY,3804
@@ -927,7 +929,7 @@ official/recommendation/uplift/metrics/variance.py,sha256=rhwZzUX-cRbwr-7vhC0I0b
 official/recommendation/uplift/metrics/variance_test.py,sha256=EPISeHOFIh6WfODuC0SXbnmMugh90acMmm4BJkEZXlo,7757
 official/recommendation/uplift/models/__init__.py,sha256=kWy2K5LGXHVyyrTjJvbVFcBjj1bjPRI2dpIq-sfdhvo,716
 official/recommendation/uplift/models/two_tower_uplift_model.py,sha256=Fb6nLFAOqch81ravK57K9kggAeqvtJcBtKGZwCex0ts,5028
-official/recommendation/uplift/models/two_tower_uplift_model_test.py,sha256=yvg-FMq66tqD9IYC0lQWZcKvs_bqmiKc5s8p2K2FFrw,8361
+official/recommendation/uplift/models/two_tower_uplift_model_test.py,sha256=J7qC9f0fDG1aIrLz85K1qUzTFyAIH0v8eA1yfPJb9YY,10061
 official/utils/__init__.py,sha256=7oiypy0N82PDw9aSdcJBLVoGTd_oRSUOdvuJhMv4leQ,609
 official/utils/hyperparams_flags.py,sha256=2FCAxfblio6ay36Yf4o7Nx188wRzFM1mbKOtVXiZCzo,4607
 official/utils/docs/__init__.py,sha256=7oiypy0N82PDw9aSdcJBLVoGTd_oRSUOdvuJhMv4leQ,609
@@ -1204,9 +1206,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.dev20240412.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240412.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240412.dist-info/METADATA,sha256=y_U6M920Hgob94pOpRJWfqistgFzPqBH0Ds0HOZOpoo,1432
-tf_models_nightly-2.17.0.dev20240412.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240412.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240412.dist-info/RECORD,,
+tf_models_nightly-2.17.0.dev20240414.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.17.0.dev20240414.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.17.0.dev20240414.dist-info/METADATA,sha256=SMm31t0MLz8wyx_vZ3yIklTbV1qbniqgblIk9XWmtEY,1432
+tf_models_nightly-2.17.0.dev20240414.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.17.0.dev20240414.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.17.0.dev20240414.dist-info/RECORD,,