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

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

{tf_models_nightly-2.17.0.dev20240413.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.dev20240413
+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.dev20240413.dist-info → tf_models_nightly-2.17.0.dev20240414.dist-info}/RECORD

@@ -915,6 +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=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
@@ -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.dev20240413.dist-info/AUTHORS,sha256=1dG3fXVu9jlo7bul8xuix5F5vOnczMk7_yWn4y70uw0,337
-tf_models_nightly-2.17.0.dev20240413.dist-info/LICENSE,sha256=WxeBS_DejPZQabxtfMOM_xn8qoZNJDQjrT7z2wG1I4U,11512
-tf_models_nightly-2.17.0.dev20240413.dist-info/METADATA,sha256=DqjFt5jNaqGygdbDJo34myYN5F7c6EboWUtItI2AQVQ,1432
-tf_models_nightly-2.17.0.dev20240413.dist-info/WHEEL,sha256=kGT74LWyRUZrL4VgLh6_g12IeVl_9u9ZVhadrgXZUEY,110
-tf_models_nightly-2.17.0.dev20240413.dist-info/top_level.txt,sha256=gum2FfO5R4cvjl2-QtP-S1aNmsvIZaFFT6VFzU0f4-g,33
-tf_models_nightly-2.17.0.dev20240413.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,,