tf-models-nightly 2.17.0.dev20240417__py2.py3-none-any.whl → 2.17.0.dev20240419__py2.py3-none-any.whl

official/recommendation/uplift/metrics/__init__.py

@@ -18,6 +18,7 @@ from official.recommendation.uplift.metrics import label_mean
 from official.recommendation.uplift.metrics import label_variance
 from official.recommendation.uplift.metrics import loss_metric
 from official.recommendation.uplift.metrics import metric_configs
+from official.recommendation.uplift.metrics import poisson_metrics
 from official.recommendation.uplift.metrics import sliced_metric
 from official.recommendation.uplift.metrics import treatment_fraction
 from official.recommendation.uplift.metrics import treatment_sliced_metric

official/recommendation/uplift/metrics/poisson_metrics.py

@@ -198,3 +198,207 @@ class LogLossMeanBaseline(tf_keras.metrics.Metric):
   @classmethod
   def from_config(cls, config: dict[str, Any]) -> LogLossMeanBaseline:
     return cls(**config)
+
+
+class LogLossMinimum(tf_keras.metrics.Metric):
+  """Computes the minimum achievable (weighted) poisson log loss.
+
+  Given labels `y` and the model's predictions `x`, the minimum loss is obtained
+  when `x` equals `y`. In this case the loss is computed as:
+  `loss = y - y * log(y) + [y * log(y) - y + 0.5 * log(2 * pi * y)]`
+
+  Note that `[y * log(y) - y + 0.5 * log(2 * pi * y)]` is only computed if
+  `compute_full_loss` is set to `True`.
+  """
+
+  def __init__(
+      self,
+      compute_full_loss: bool = False,
+      slice_by_treatment: bool = True,
+      name: str = "poisson_log_loss_minimum",
+      dtype: tf.DType = tf.float32,
+  ):
+    """Initializes the instance.
+
+    Args:
+      compute_full_loss: Specifies whether to compute the full minimum log loss
+        or not. Defaults to `False`.
+      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__(name=name, dtype=dtype)
+
+    if compute_full_loss:
+      raise NotImplementedError("Full loss computation is not yet supported.")
+
+    self._compute_full_loss = compute_full_loss
+    self._slice_by_treatment = slice_by_treatment
+
+    if slice_by_treatment:
+      self._loss = treatment_sliced_metric.TreatmentSlicedMetric(
+          metric=tf_keras.metrics.Mean(name=name, dtype=dtype)
+      )
+    else:
+      self._loss = tf_keras.metrics.Mean(name=name, dtype=dtype)
+
+  def update_state(
+      self,
+      y_true: tf.Tensor,
+      y_pred: types.TwoTowerTrainingOutputs | tf.Tensor | None = None,
+      sample_weight: tf.Tensor | None = None,
+  ):
+    is_treatment = {}
+    if self._slice_by_treatment:
+      if not isinstance(y_pred, types.TwoTowerTrainingOutputs):
+        raise ValueError(
+            "`slice_by_treatment` must be set to `False` when `y_pred` is not"
+            " of type `TwoTowerTrainingOutputs`."
+        )
+      is_treatment["is_treatment"] = y_pred.is_treatment
+
+    self._loss.update_state(
+        _safe_x_minus_xlogx(y_true), sample_weight=sample_weight, **is_treatment
+    )
+
+  def result(self) -> tf.Tensor | dict[str, tf.Tensor]:
+    return self._loss.result()
+
+  def get_config(self) -> dict[str, Any]:
+    config = super().get_config()
+    config["compute_full_loss"] = self._compute_full_loss
+    config["slice_by_treatment"] = self._slice_by_treatment
+    return config
+
+  @classmethod
+  def from_config(cls, config: dict[str, Any]) -> LogLossMinimum:
+    return cls(**config)
+
+
+class PseudoRSquared(tf_keras.metrics.Metric):
+  """Computes the pseudo R-squared metric for poisson regression.
+
+  The pseudo R-squared is computed from log likelihoods of three models:
+  1) LLbaseline: log likelihood of a mean baseline predictor.
+  2) LLfit: log likelihood of the fitted model.
+  3) LLmax: maximum achievable log likelihood, which occurs when the predictions
+  equal to the labels.
+
+  The equation that computes the pseudo R-squared is:
+  >>> R_squared = (LLfit - LLbaseline) / (LLmax - LLbaseline)
+  """
+
+  def __init__(
+      self,
+      from_logits: bool = True,
+      slice_by_treatment: bool = True,
+      name: str = "pseudo_r_squared",
+      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.
+      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__(name=name, dtype=dtype)
+
+    self._from_logits = from_logits
+    self._slice_by_treatment = slice_by_treatment
+
+    # Since log_loss = -1 * log_likelihood we can just accumulate the losses.
+    loss = LogLoss(
+        from_logits=from_logits,
+        compute_full_loss=False,
+        slice_by_treatment=False,
+        name=name,
+        dtype=dtype,
+    )
+    minimum_loss = LogLossMinimum(
+        compute_full_loss=False,
+        slice_by_treatment=False,
+        name=name,
+        dtype=dtype,
+    )
+    mean_baseline_loss = LogLossMeanBaseline(
+        compute_full_loss=False,
+        slice_by_treatment=False,
+        name=name,
+        dtype=dtype,
+    )
+
+    if slice_by_treatment:
+      self._model_loss = treatment_sliced_metric.TreatmentSlicedMetric(
+          metric=loss
+      )
+      self._minimum_loss = treatment_sliced_metric.TreatmentSlicedMetric(
+          metric=minimum_loss
+      )
+      self._mean_baseline_loss = treatment_sliced_metric.TreatmentSlicedMetric(
+          metric=mean_baseline_loss
+      )
+    else:
+      self._model_loss = loss
+      self._minimum_loss = minimum_loss
+      self._mean_baseline_loss = mean_baseline_loss
+
+  def update_state(
+      self,
+      y_true: tf.Tensor,
+      y_pred: types.TwoTowerTrainingOutputs | tf.Tensor,
+      sample_weight: tf.Tensor | None = None,
+  ):
+    is_treatment = {}
+    if self._slice_by_treatment:
+      if not isinstance(y_pred, types.TwoTowerTrainingOutputs):
+        raise ValueError(
+            "`slice_by_treatment` must be set to `False` when `y_pred` is not"
+            " of type `TwoTowerTrainingOutputs`."
+        )
+      is_treatment["is_treatment"] = y_pred.is_treatment
+
+    self._model_loss.update_state(
+        y_true, y_pred=y_pred, sample_weight=sample_weight, **is_treatment
+    )
+    self._minimum_loss.update_state(
+        y_true, y_pred=y_pred, sample_weight=sample_weight, **is_treatment
+    )
+    self._mean_baseline_loss.update_state(
+        y_true, y_pred=y_pred, sample_weight=sample_weight, **is_treatment
+    )
+
+  def result(self) -> tf.Tensor | dict[str, tf.Tensor]:
+    def _pseudo_r_squared(
+        loss_model: tf.Tensor, loss_baseline: tf.Tensor, loss_min: tf.Tensor
+    ) -> tf.Tensor:
+      return tf.math.divide_no_nan(
+          loss_model - loss_baseline, loss_min - loss_baseline
+      )
+
+    return tf.nest.map_structure(
+        _pseudo_r_squared,
+        self._model_loss.result(),
+        self._mean_baseline_loss.result(),
+        self._minimum_loss.result(),
+    )
+
+  def get_config(self) -> dict[str, Any]:
+    config = super().get_config()
+    config["from_logits"] = self._from_logits
+    config["slice_by_treatment"] = self._slice_by_treatment
+    return config
+
+  @classmethod
+  def from_config(cls, config: dict[str, Any]) -> PseudoRSquared:
+    return cls(**config)

official/recommendation/uplift/metrics/poisson_metrics_test.py

@@ -256,5 +256,194 @@ class LogLossMeanBaselineTest(
     )
 
 
+class LogLossMinimumTest(keras_test_case.KerasTestCase, parameterized.TestCase):
+
+  @parameterized.named_parameters(
+      {
+          "testcase_name": "label_zero",
+          "expected_loss": 0.0,
+          "y_true": tf.constant([0], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "small_positive_label",
+          "expected_loss": 0.0,
+          "y_true": tf.constant([1e-10], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "label_one",
+          "expected_loss": 1.0,
+          "y_true": tf.constant([1], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "weighted_loss",
+          "expected_loss": 1.0,
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "sample_weight": tf.constant([[0], [1]], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "two_tower_outputs",
+          "expected_loss": 0.5,
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              is_treatment=tf.constant([[0], [1]], dtype=tf.float32),
+          ),
+      },
+      {
+          "testcase_name": "two_tower_outputs_sliced_loss",
+          "expected_loss": {
+              "loss": 0.5,
+              "loss/control": 0.0,
+              "loss/treatment": 1.0,
+          },
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              is_treatment=tf.constant([[0], [1]], dtype=tf.float32),
+          ),
+          "slice_by_treatment": True,
+      },
+  )
+  def test_metric_computes_correct_loss(
+      self,
+      expected_loss: tf.Tensor,
+      y_true: tf.Tensor,
+      y_pred: types.TwoTowerTrainingOutputs | tf.Tensor | None = None,
+      sample_weight: tf.Tensor | None = None,
+      slice_by_treatment: bool = False,
+  ):
+    metric = poisson_metrics.LogLossMinimum(
+        slice_by_treatment=slice_by_treatment, name="loss"
+    )
+    metric.update_state(y_true, y_pred, sample_weight=sample_weight)
+    self.assertAllClose(expected_loss, metric.result())
+
+  def test_negative_label_returns_nan_loss(self):
+    metric = poisson_metrics.LogLossMinimum(slice_by_treatment=False)
+    metric.update_state(tf.constant([-1.0]))
+    self.assertTrue(tf.math.is_nan(metric.result()).numpy().item())
+
+  def test_metric_is_configurable(self):
+    metric = poisson_metrics.LogLossMinimum(slice_by_treatment=False)
+    self.assertLayerConfigurable(
+        layer=metric,
+        y_true=tf.constant([[0], [0], [2], [7]], dtype=tf.float32),
+        serializable=True,
+    )
+
+
+class PseudoRSquaredTest(keras_test_case.KerasTestCase, parameterized.TestCase):
+
+  @parameterized.named_parameters(
+      {
+          "testcase_name": "no_data",
+          "expected_loss": 0.0,
+          "y_true": tf.constant([], dtype=tf.float32),
+          "y_pred": tf.constant([], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "one_correct_prediction",
+          "expected_loss": 0.0,
+          "y_true": tf.constant([1], dtype=tf.float32),
+          "y_pred": tf.constant([1], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "one_wrong_prediction",
+          "expected_loss": 0.0,  # LLmax and LLbaseline are equal.
+          "y_true": tf.constant([0], dtype=tf.float32),
+          "y_pred": tf.constant([1], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "all_correct_predictions",
+          "expected_loss": 1.0,
+          "y_true": tf.constant([[1], [2], [3]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [2], [3]], dtype=tf.float32),
+          "from_logits": False,
+      },
+      {
+          "testcase_name": "almost_correct_predictions",
+          "expected_loss": 1.0,
+          "y_true": tf.constant([[1], [2], [3]], dtype=tf.float32),
+          "y_pred": tf.constant([[1], [1.9999], [3.0001]], dtype=tf.float32),
+      },
+      {
+          "testcase_name": "from_logits",
+          "expected_loss": (
+              (tf.math.exp(1.0) / 2) - (0.5 - 0.5 * tf.math.log(0.5))
+          ) / (0.5 - (0.5 - 0.5 * tf.math.log(0.5))),
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "y_pred": tf.constant([[0], [1]], dtype=tf.float32),
+          "from_logits": True,
+      },
+      {
+          "testcase_name": "two_tower_outputs",
+          "expected_loss": (
+              ((tf.math.exp(1.0) - 1) + 1) / 2 - (0.5 - 0.5 * tf.math.log(0.5))
+          ) / (0.5 - (0.5 - 0.5 * tf.math.log(0.5))),
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              true_logits=tf.constant([[0], [1]], dtype=tf.float32),
+              is_treatment=tf.constant([[0], [1]], dtype=tf.float32),
+          ),
+          "from_logits": True,
+      },
+      {
+          "testcase_name": "two_tower_outputs_sliced_loss",
+          "expected_loss": {
+              "r2": (
+                  ((tf.math.exp(1.0) - 1) + 1) / 2  # LLfit
+                  - (0.5 - 0.5 * tf.math.log(0.5))  # LLbaseline
+              ) / (0.5 - (0.5 - 0.5 * tf.math.log(0.5))),
+              "r2/control": 0.0,
+              "r2/treatment": 0.0,
+          },
+          "y_true": tf.constant([[0], [1]], dtype=tf.float32),
+          "y_pred": _get_two_tower_outputs(
+              true_logits=tf.constant([[0], [1]], dtype=tf.float32),
+              is_treatment=tf.constant([[0], [1]], dtype=tf.float32),
+          ),
+          "from_logits": True,
+          "slice_by_treatment": True,
+      },
+  )
+  def test_metric_computation_is_correct(
+      self,
+      expected_loss: tf.Tensor,
+      y_true: tf.Tensor,
+      y_pred: types.TwoTowerTrainingOutputs | tf.Tensor,
+      sample_weight: tf.Tensor | None = None,
+      from_logits: bool = False,
+      slice_by_treatment: bool = False,
+  ):
+    metric = poisson_metrics.PseudoRSquared(
+        from_logits=from_logits,
+        slice_by_treatment=slice_by_treatment,
+        name="r2",
+    )
+    metric.update_state(y_true, y_pred, sample_weight=sample_weight)
+    self.assertAllClose(expected_loss, metric.result())
+
+  def test_slicing_raises_error_when_input_is_tensor(self):
+    metric = poisson_metrics.PseudoRSquared()
+    y_true = tf.constant([[0], [0], [2], [7]], dtype=tf.float32)
+    y_pred = tf.constant([[1], [2], [3], [4]], dtype=tf.float32)
+    with self.assertRaisesRegex(
+        ValueError,
+        "`slice_by_treatment` must be set to `False` when `y_pred` is not of"
+        " type `TwoTowerTrainingOutputs`.",
+    ):
+      metric(y_true, y_pred)
+
+  @parameterized.parameters(True, False)
+  def test_metric_is_configurable(self, from_logits: bool):
+    metric = poisson_metrics.PseudoRSquared(
+        from_logits=from_logits, 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/vision/modeling/backbones/mobilenet.py

@@ -625,6 +625,14 @@ MNV3SmallReducedFilters = {
 }
 
 
+"""
+Architecture: https://arxiv.org/abs/2404.10518
+
+"MobileNetV4 - Universal Models for the Mobile Ecosystem"
+Danfeng Qin, Chas Leichner, Manolis Delakis, Marco Fornoni, Shixin Luo, Fan
+Yang, Weijun Wang, Colby Banbury, Chengxi Ye, Berkin Akin, Vaibhav Aggarwal,
+Tenghui Zhu, Daniele Moro, Andrew Howard
+"""
 MNV4ConvSmall_BLOCK_SPECS = {
     'spec_name': 'MobileNetV4ConvSmall',
     'block_spec_schema': [

{tf_models_nightly-2.17.0.dev20240417.dist-info → tf_models_nightly-2.17.0.dev20240419.dist-info}/METADATA

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

{tf_models_nightly-2.17.0.dev20240417.dist-info → tf_models_nightly-2.17.0.dev20240419.dist-info}/RECORD

@@ -907,7 +907,7 @@ official/recommendation/uplift/layers/uplift_networks/two_tower_uplift_network_t
 official/recommendation/uplift/losses/__init__.py,sha256=b1_FBAD9SWUy8-Wfs2KeiER5WappdJ_sE4dDzip2k6w,711
 official/recommendation/uplift/losses/true_logits_loss.py,sha256=YrI89Fgcg1fEIpAFczzyNS0Ty9YXa_XClXgqlDsNh10,3524
 official/recommendation/uplift/losses/true_logits_loss_test.py,sha256=xF91tzTarqG9lNfE8HSYVvRy-dpjP8bJ8FYpHUg3H6U,3105
-official/recommendation/uplift/metrics/__init__.py,sha256=qdlYbLPbVMpHUACS1Mobo9chcOyiRj3uLp0ZM-hOVH8,1234
+official/recommendation/uplift/metrics/__init__.py,sha256=0YyJbxTptbh3RQYTeqwnD_YIIc86KeX2ot-C-vQcD6E,1301
 official/recommendation/uplift/metrics/label_mean.py,sha256=ECaes7FZmsksnwySn7jfTR4IZeOu3X0ZOOx4UiCo7CI,3494
 official/recommendation/uplift/metrics/label_mean_test.py,sha256=b_d3lNlpkDm2xKLUkxfiXeQg7pjL8HNx7y9NaYarpV0,7083
 official/recommendation/uplift/metrics/label_variance.py,sha256=9DCl42BJkehxfWD3pSbZnRNvwfhVM6VyHwivGdaU72s,3610
@@ -915,8 +915,8 @@ official/recommendation/uplift/metrics/label_variance_test.py,sha256=k0mdEU1WU53
 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/poisson_metrics.py,sha256=1a0sHwdOLUVhmsdpnZIQxAWkt3QAPWS9TZCK6P9H7ug,7443
-official/recommendation/uplift/metrics/poisson_metrics_test.py,sha256=sLx4RjtvJiD8kRkXBDfsUANK0P5LSMfTTPj9GF73wOw,9473
+official/recommendation/uplift/metrics/poisson_metrics.py,sha256=ZltEopHvYJlrqjVr9X_NhNQOwWcv2O3rFqvKVVTC57I,14475
+official/recommendation/uplift/metrics/poisson_metrics_test.py,sha256=zGo7Y7XJY4kvecoeAy7Jci_N3YZKMTKpj28j7ZtoTLc,16378
 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
@@ -1049,7 +1049,7 @@ official/vision/modeling/backbones/factory.py,sha256=coJKJpPMhgM9gAc2Q7I5_CuzAaH
 official/vision/modeling/backbones/factory_test.py,sha256=7ZJRDSQ_cqJFyfqLK375V_wEqgrQpqibzNDZzNbhthU,8635
 official/vision/modeling/backbones/mobiledet.py,sha256=iEC_KbqYqUBBBwZUfRCVtqllQwK6N4T1jmiDl29B-Ys,24896
 official/vision/modeling/backbones/mobiledet_test.py,sha256=O2yfL7MSCGtKsnXr0IVUtjicrhZGGkwTXWCLtqdsL0Y,3804
-official/vision/modeling/backbones/mobilenet.py,sha256=dVABJm7mRizcqwVFiWjulb6aIGgVoa4JuUX5ms_H7II,60978
+official/vision/modeling/backbones/mobilenet.py,sha256=iwUS9WSAZA6cyagw2Ld1zUlyR1MmvA9-AS7Gm4M8HZA,61286
 official/vision/modeling/backbones/mobilenet_test.py,sha256=7cl5eerD5j5UqHL8SLmpou-PjufBz8oz_cn3tqwW1vM,13057
 official/vision/modeling/backbones/resnet.py,sha256=dnYkdlYUzChGLOrQnUbwb9YJ7BDiFwgnLptks7kFb7k,16384
 official/vision/modeling/backbones/resnet_3d.py,sha256=Cq1lrlRqIg9ss_ud1iM_axW9lsTVtGYe3iA4DL9Orzk,18657
@@ -1206,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.dev20240417.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240417.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240417.dist-info/METADATA,sha256=Sft4CH1GT2IMtgKOIyKA8O9FFE9nlzhWqHn2oHYV-G4,1432
-tf_models_nightly-2.17.0.dev20240417.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240417.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240417.dist-info/RECORD,,
+tf_models_nightly-2.17.0.dev20240419.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
+tf_models_nightly-2.17.0.dev20240419.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
+tf_models_nightly-2.17.0.dev20240419.dist-info/METADATA,sha256=cjn3N2Dkx92tEh3AiEj4KT7yJymVEI7vBc_DMnQBpI4,1432
+tf_models_nightly-2.17.0.dev20240419.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
+tf_models_nightly-2.17.0.dev20240419.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
+tf_models_nightly-2.17.0.dev20240419.dist-info/RECORD,,